Merge lp:~phablet-team/ofono/update-july-first into lp:~phablet-team/ofono/ubuntu

[Alfonso Sanchez-Beato]

[Tony Espy]
* test/rilmodem/sim: fix testing scripts for arale
* test: reverse meaning of list-modems -p
[ Alfonso Sanchez-Beato ]
* gril: cleanup traces
* src/gprs.c: set preferred for the used IA APN
* rilmodem, mtkmodem, plugins/ril.c, plugins/mtk.c: retry when a
  context deactivation request has finished with an error
* build, include, plugins/c-ares-dns-client.c, src/dns-client.c,
  src/gprs.c: resolve MMS proxy/MMSC host name (LP: #1417976)
[ Ratchanan Srirattanamet ]
* build, rilmodem, qcommsimmodem, plugins/ril.c,
  src/radio-settings.c: add multi-sim support for qcommsimmodem

[Tony Espy]
* test/rilmodem/sim: fix testing scripts for arale
* test: reverse meaning of list-modems -p
[ Alfonso Sanchez-Beato ]
* gril: cleanup traces
* src/gprs.c: set preferred for the used IA APN
* rilmodem, mtkmodem, plugins/ril.c, plugins/mtk.c: retry when a
  context deactivation request has finished with an error
* build, include, plugins/c-ares-dns-client.c, src/dns-client.c,
  src/gprs.c: resolve MMS proxy/MMSC host name (LP: #1417976)
[ Ratchanan Srirattanamet ]
* build, rilmodem, qcommsimmodem, plugins/ril.c,
  src/radio-settings.c: add multi-sim support for qcommsimmodem

[lp:~phablet-team/ofono/update-july-first]

6899. By Alfonso Sanchez-Beato on 2015-07-01

Add c-ares-dev to debian build dependencies

6900. By Alfonso Sanchez-Beato on 2015-07-01

Fix printing context properties

[Tony Espy (awe)]

The code all looks good. That said, the changelog needs some fixing ( see inline comments ).

review: Needs Fixing

[lp:~phablet-team/ofono/update-july-first]

6901. By Alfonso Sanchez-Beato on 2015-07-02

Fix changelog

6902. By Alfonso Sanchez-Beato on 2015-07-02

Fix debian package version

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

Changelog changed adding bug numbers, but I have not reverted the package version number because the actual version produced in the silo is 6900. I think that at some moment there has been a mismatch between changelog version and the version in the package name, and using 6900 we get both things synced again.

[Tony Espy (awe)]

The version in the silo is 6900 because that's what you told it to build.

Again, the latest version in trunk is 6897, so the merge will be 6898 in trunk, which != 6900, so the versions will actually not be in sync... Let's discuss at our net/telephony meeting.

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

No, I did change the version to 6898 in the changelog, and the package version was still 6900. It takes the bzr branch version, not the version from the changelog.

[lp:~phablet-team/ofono/update-july-first]

6903. By Alfonso Sanchez-Beato on 2015-07-02

Fix changelog

[Tony Espy (awe)]

review: Approve

[lp:~phablet-team/ofono/update-july-first]

6904. By Alfonso Sanchez-Beato on 2015-07-02

Fix package version

6905. By Alfonso Sanchez-Beato on 2015-07-02

Fix version to 6900

[Tony Espy (awe)]

Tested mako ( rc/ubuntu #1 ); Note, the latest version of network-manager (4ubuntu15.1.4) from the overlay PPA was also installed.

Ran the Basic Tests from:

https://wiki.ubuntu.com/Process/Merges/TestPlans/ofono

Also verified that MMS can be sent & received using AT&T, which provision an APN that specifies a non-dotted-IP-address MessageProxy ( proxy.mobile.att:80 ). Both sending and receiving worked as expected.

Verified that the list-modems privacy flag has indeed been reversed, and also checked that the rilmodem test scripts didn't break due to an arale fix contained in this merge. Did find one bug in one of the test scripts though ( not a regression ):

https://bugs.launchpad.net/ubuntu/+source/ofono/+bug/1471019

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

Tested on arale (devel-proposed, #41)

Ran the Basic Tests from:

https://wiki.ubuntu.com/Process/Merges/TestPlans/ofono

Restoring cellular mode after unsetting flight mode failed, which was expected as the NM version that fixes this has not landed in wily.

Verified bugs #1438715, #1457775, #1361864 are fixed.

MMS tx/rx working for pepephone operator.

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

Tested on krillin (rc-proposed, #56)

Ran the Basic Tests from:

https://wiki.ubuntu.com/Process/Merges/TestPlans/ofono

Verified bugs #1438715, #1361864 are fixed.

MMS tx/rx working for pepephone operator.

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

Vivid silo tested on krillin (rc-proposed, #56)

Ran the Basic Tests from:

https://wiki.ubuntu.com/Process/Merges/TestPlans/ofono

MMS tx/rx working for pepephone operator.

=== modified file 'Makefile.am'
--- Makefile.am	2015-05-20 16:32:09 +0000
+++ Makefile.am	2015-07-02 17:01:42 +0000
@@ -19,7 +19,8 @@
 			include/cdma-connman.h include/gnss.h \
 			include/private-network.h include/cdma-netreg.h \
 			include/cdma-provision.h include/handsfree.h \
-			include/sim-mnclength.h include/spn-table.h
+			include/sim-mnclength.h include/spn-table.h \
+			include/dns-client.h
 
 nodist_pkginclude_HEADERS = include/version.h
 
@@ -172,6 +173,10 @@
 			drivers/rilmodem/radio-settings.c \
 			drivers/rilmodem/call-barring.c \
 			drivers/rilmodem/phonebook.c
+
+builtin_modules += qcommsimmodem
+builtin_sources += drivers/qcommsimmodem/qcom_msim_modem.c \
+			drivers/qcommsimmodem/radio-settings.c
 endif
 
 if ISIMODEM
@@ -530,6 +535,14 @@
 builtin_sources += plugins/mnclength.c
 endif
 
+if CARES
+builtin_modules += c_ares_dns_client
+builtin_sources += plugins/c-ares-dns-client.c
+
+builtin_cflags += @CARES_CFLAGS@
+builtin_libadd += @CARES_LIBS@
+endif
+
 if MAINTAINER_MODE
 builtin_modules += example_history
 builtin_sources += examples/history.c
@@ -585,7 +598,8 @@
 			src/cdma-smsutil.h src/cdma-smsutil.c \
 			src/cdma-sms.c src/private-network.c src/cdma-netreg.c \
 			src/cdma-provision.c src/handsfree.c \
-			src/sim-mnclength.c src/spn-table.c
+			src/sim-mnclength.c src/spn-table.c \
+			src/dns-client.c
 
 src_ofonod_LDADD = $(builtin_libadd) @GLIB_LIBS@ @DBUS_LIBS@ -ldl
 

=== modified file 'configure.ac'
--- configure.ac	2014-06-24 18:59:26 +0000
+++ configure.ac	2015-07-02 17:01:42 +0000
@@ -188,6 +188,17 @@
 AC_SUBST(BLUEZ_LIBS)
 AM_CONDITIONAL(BLUETOOTH, test "${enable_bluetooth}" != "no")
 
+AC_ARG_ENABLE(cares, AC_HELP_STRING([--disable-cares],
+				[disable DNS client using c-ares library]),
+						[enable_cares=${enableval}])
+if (test "${enable_cares}" != "no"); then
+	PKG_CHECK_MODULES(CARES, libcares, dummy=yes,
+					AC_MSG_ERROR(libcares is required))
+fi
+AC_SUBST(CARES_CFLAGS)
+AC_SUBST(CARES_LIBS)
+AM_CONDITIONAL(CARES, test "${enable_cares}" != "no")
+
 AC_ARG_ENABLE(nettime, AC_HELP_STRING([--disable-nettime],
                                 [disable Nettime plugin]),
                                         [enable_nettime=${enableval}])

=== modified file 'debian/changelog'
--- debian/changelog	2015-05-21 08:44:39 +0000
+++ debian/changelog	2015-07-02 17:01:42 +0000
@@ -1,3 +1,23 @@
+ofono (1.12.bzr6900+15.04.20150701-0ubuntu1) UNRELEASED; urgency=medium
+
+  [Tony Espy]
+  * test/rilmodem/sim: fix testing scripts for arale (LP: #1457775)
+  * test: reverse meaning of list-modems -p (LP: #1438715)
+
+  [ Alfonso Sanchez-Beato ]
+  * gril: cleanup traces
+  * src/gprs.c: set preferred for the used IA APN (LP: #1361864)
+  * rilmodem, mtkmodem, plugins/ril.c, plugins/mtk.c: retry when a
+    context deactivation request has finished with an error
+  * build, include, plugins/c-ares-dns-client.c, src/dns-client.c,
+    src/gprs.c: resolve MMS proxy/MMSC host name (LP: #1417976)
+
+  [ Ratchanan Srirattanamet ]
+  * build, rilmodem, qcommsimmodem, plugins/ril.c,
+    src/radio-settings.c: add multi-sim support for qcommsimmodem
+
+ -- Alfonso Sanchez-Beato (email Canonical) <[e-mail]>  Wed, 01 Jul 2015 08:40:36 +0200
+
 ofono (1.12.bzr6896+15.04.20150521-0ubuntu1) vivid; urgency=medium
 
   [ Ratchanan Srirattanamet ]

=== modified file 'debian/control'
--- debian/control	2015-01-12 10:01:50 +0000
+++ debian/control	2015-07-02 17:01:42 +0000
@@ -13,7 +13,8 @@
                libudev-dev,
                udev,
                libbluetooth-dev (>= 4.30),
-               mobile-broadband-provider-info
+               mobile-broadband-provider-info,
+               libc-ares-dev
 Standards-Version: 3.9.4
 Homepage: http://www.ofono.org/
 # If you aren't a member of ~phablet-team but need to upload

=== modified file 'drivers/mtkmodem/mtkutil.h'
--- drivers/mtkmodem/mtkutil.h	2015-01-29 14:50:30 +0000
+++ drivers/mtkmodem/mtkutil.h	2015-07-02 17:01:42 +0000
@@ -35,6 +35,7 @@
 void mtk_detach_received(struct ofono_modem *modem);
 
 void mtk_reset_all_modems(void);
+void mtk_reset_modem(struct ofono_modem *modem);
 
 const char *mtk_request_id_to_string(int req);
 const char *mtk_unsol_request_to_string(int req);

=== modified file 'drivers/qcommsimmodem/qcom_msim_constants.h'
--- drivers/qcommsimmodem/qcom_msim_constants.h	2015-04-23 13:08:30 +0000
+++ drivers/qcommsimmodem/qcom_msim_constants.h	2015-07-02 17:01:42 +0000
@@ -22,6 +22,8 @@
 #ifndef QCOM_MSIM_CONSTANTS_H
 #define QCOM_MSIM_CONSTANTS_H
 
+#define QCOMMSIM_NUM_SLOTS_MAX 2
+
 #define QCOM_MSIM_RIL_REQUEST_SET_UICC_SUBSCRIPTION  115
 
 #endif /* QCOM_MSIM_CONSTANTS_H */

=== added file 'drivers/qcommsimmodem/qcom_msim_modem.c'
--- drivers/qcommsimmodem/qcom_msim_modem.c	1970-01-01 00:00:00 +0000
+++ drivers/qcommsimmodem/qcom_msim_modem.c	2015-07-02 17:01:42 +0000
@@ -0,0 +1,56 @@
+/*
+ *
+ *  oFono - Open Source Telephony - RIL Modem Support
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012 Canonical, Ltd. All rights reserved.
+ *  Copyright (C) 2015 Ratchanan Srirattanamet.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+#include <gril.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+#include <ofono/plugin.h>
+#include <ofono/log.h>
+#include <ofono/types.h>
+
+#include "qcom_msim_modem.h"
+
+static int qcom_msim_modem_init(void)
+{
+	DBG("");
+
+	qcom_msim_radio_settings_init();
+
+	return 0;
+}
+
+static void qcom_msim_modem_exit(void)
+{
+	DBG("");
+
+	qcom_msim_radio_settings_exit();
+}
+
+OFONO_PLUGIN_DEFINE(qcommsimmodem, "Qualcomm multi-sim modem driver", VERSION,
+				OFONO_PLUGIN_PRIORITY_DEFAULT,
+				qcom_msim_modem_init, qcom_msim_modem_exit)

=== added file 'drivers/qcommsimmodem/qcom_msim_modem.h'
--- drivers/qcommsimmodem/qcom_msim_modem.h	1970-01-01 00:00:00 +0000
+++ drivers/qcommsimmodem/qcom_msim_modem.h	2015-07-02 17:01:42 +0000
@@ -0,0 +1,25 @@
+/*
+ *
+ *  oFono - Open Source Telephony - RIL Modem Support
+ *
+ *  Copyright (C) 2015 Ratchanan Srirattanamet
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#define QCOMMSIMMODEM "qcommsimmodem"
+
+extern void qcom_msim_radio_settings_init(void);
+extern void qcom_msim_radio_settings_exit(void);

=== added file 'drivers/qcommsimmodem/radio-settings.c'
--- drivers/qcommsimmodem/radio-settings.c	1970-01-01 00:00:00 +0000
+++ drivers/qcommsimmodem/radio-settings.c	2015-07-02 17:01:42 +0000
@@ -0,0 +1,270 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2014  Canonical Ltd.
+ *  Copyright (C) 2015 Ratchanan Srirattanamet
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <glib.h>
+
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/radio-settings.h>
+
+#include "gril.h"
+#include "grilrequest.h"
+#include "grilreply.h"
+
+#include "drivers/rilmodem/radio-settings.h"
+#include "drivers/rilmodem/rilutil.h"
+#include "qcom_msim_modem.h"
+#include "qcom_msim_constants.h"
+
+struct qcom_msim_pending_pref_setting {
+	struct ofono_radio_settings *rs;
+	int pref;
+	int pending_gsm_pref_remaining;
+	struct cb_data *cbd;
+};
+
+struct qcom_msim_set_2g_rat {
+	struct ofono_radio_settings *rs;
+	struct qcom_msim_pending_pref_setting *pps;
+};
+
+static struct ofono_radio_settings *multisim_rs[QCOMMSIM_NUM_SLOTS_MAX];
+static int multisim_num_slots;
+
+static void qcom_msim_set_rat_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	struct ofono_radio_settings *rs = cbd->user;
+	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+	ofono_radio_settings_rat_mode_set_cb_t cb = cbd->cb;
+
+	if (message->error == RIL_E_SUCCESS) {
+		g_ril_print_response_no_args(rd->ril, message);
+		CALLBACK_WITH_SUCCESS(cb, cbd->data);
+	} else {
+		ofono_error("%s: rat mode setting failed", __func__);
+		CALLBACK_WITH_FAILURE(cb, cbd->data);
+	}
+}
+
+static void qcom_msim_set_2g_rat_cb(struct ril_msg *message,
+							gpointer user_data)
+{
+	struct qcom_msim_set_2g_rat *set_2g_rat_data = user_data;
+	struct ofono_radio_settings *rs = set_2g_rat_data->rs;
+	struct qcom_msim_pending_pref_setting *pps = set_2g_rat_data->pps;
+	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+	ofono_radio_settings_rat_mode_set_cb_t cb;
+	struct parcel rilp;
+
+	pps->pending_gsm_pref_remaining -= 1;
+
+	if (message->error == RIL_E_SUCCESS) {
+		g_ril_print_response_no_args(rd->ril, message);
+		ofono_radio_settings_set_rat_mode(rs,
+						OFONO_RADIO_ACCESS_MODE_GSM);
+	} else {
+		ofono_error("%s: rat mode setting failed", __func__);
+		if (pps->cbd != NULL) {
+			cb = pps->cbd->cb;
+			CALLBACK_WITH_FAILURE(cb, pps->cbd->data);
+
+			g_free(pps->cbd);
+			pps->cbd = NULL;
+		}
+	}
+
+	if (pps->pending_gsm_pref_remaining == 0) {
+		if (pps->cbd != NULL) {
+			struct radio_data *pps_rd =
+					ofono_radio_settings_get_data(pps->rs);
+			g_ril_request_set_preferred_network_type(pps_rd->ril,
+							pps->pref, &rilp);
+
+			if (g_ril_send(pps_rd->ril,
+					RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE,
+					&rilp, qcom_msim_set_rat_cb, pps->cbd,
+					g_free) == 0) {
+				ofono_error("%s: unable to set rat mode",
+								__func__);
+				cb = pps->cbd->cb;
+				CALLBACK_WITH_FAILURE(cb, pps->cbd->data);
+				g_free(pps->cbd);
+			}
+		}
+
+		g_free(pps);
+	}
+}
+
+static void qcom_msim_set_rat_mode(struct ofono_radio_settings *rs,
+			enum ofono_radio_access_mode mode,
+			ofono_radio_settings_rat_mode_set_cb_t cb,
+			void *data)
+{
+	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+	struct cb_data *cbd = cb_data_new(cb, data, rs);
+	struct parcel rilp;
+	int pref = PREF_NET_TYPE_GSM_WCDMA;
+
+	switch (mode) {
+	case OFONO_RADIO_ACCESS_MODE_ANY:
+		pref = PREF_NET_TYPE_LTE_GSM_WCDMA;
+		break;
+	case OFONO_RADIO_ACCESS_MODE_GSM:
+		pref = PREF_NET_TYPE_GSM_ONLY;
+		break;
+	case OFONO_RADIO_ACCESS_MODE_UMTS:
+		pref = PREF_NET_TYPE_GSM_WCDMA;
+		break;
+	case OFONO_RADIO_ACCESS_MODE_LTE:
+		pref = PREF_NET_TYPE_LTE_GSM_WCDMA;
+		break;
+	}
+
+	if (pref != PREF_NET_TYPE_GSM_ONLY && multisim_num_slots > 1) {
+		struct qcom_msim_pending_pref_setting *pps =
+			g_try_new0(struct qcom_msim_pending_pref_setting, 1);
+		int i;
+
+		pps->rs = rs;
+		pps->pref = pref;
+		pps->cbd = cbd;
+		pps->pending_gsm_pref_remaining = 0;
+
+		for (i = 0; i < QCOMMSIM_NUM_SLOTS_MAX; i++) {
+			struct radio_data *temp_rd;
+			struct qcom_msim_set_2g_rat *set_2g_rat_data;
+
+			if (multisim_rs[i] == rs || multisim_rs[i] == NULL)
+				continue;
+
+			temp_rd = ofono_radio_settings_get_data(multisim_rs[i]);
+			set_2g_rat_data =
+				g_try_new0(struct qcom_msim_set_2g_rat, 1);
+			set_2g_rat_data->pps = pps;
+			set_2g_rat_data->rs = multisim_rs[i];
+
+			g_ril_request_set_preferred_network_type(temp_rd->ril,
+						PREF_NET_TYPE_GSM_ONLY, &rilp);
+
+			if (g_ril_send(temp_rd->ril,
+					RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE,
+					&rilp, qcom_msim_set_2g_rat_cb,
+					set_2g_rat_data, g_free) == 0) {
+				ofono_error("%s: unable to set rat mode",
+								__func__);
+				pps->cbd = NULL;
+				g_free(cbd);
+				g_free(set_2g_rat_data);
+				CALLBACK_WITH_FAILURE(cb, data);
+				break;
+			} else {
+				pps->pending_gsm_pref_remaining += 1;
+			}
+		}
+
+		if (pps->pending_gsm_pref_remaining == 0)
+			g_free(pps);
+	} else {
+		g_ril_request_set_preferred_network_type(rd->ril, pref, &rilp);
+
+		if (g_ril_send(rd->ril, RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE,
+					&rilp, qcom_msim_set_rat_cb, cbd,
+					g_free) == 0) {
+			ofono_error("%s: unable to set rat mode", __func__);
+			g_free(cbd);
+			CALLBACK_WITH_FAILURE(cb, data);
+		}
+	}
+}
+
+static int qcom_msim_radio_settings_probe(struct ofono_radio_settings *rs,
+					unsigned int vendor, void *user)
+{
+	struct ril_radio_settings_driver_data *rs_init_data = user;
+	struct radio_data *rsd = g_try_new0(struct radio_data, 1);
+	int slot_id;
+
+	if (rsd == NULL) {
+		ofono_error("%s: cannot allocate memory", __func__);
+		return -ENOMEM;
+	}
+
+	rsd->ril = g_ril_clone(rs_init_data->gril);
+	rsd->modem = rs_init_data->modem;
+
+	ofono_radio_settings_set_data(rs, rsd);
+
+	ril_set_fast_dormancy(rs, FALSE, ril_delayed_register, rs);
+
+	slot_id = ofono_modem_get_integer(rsd->modem, "Slot");
+	multisim_rs[slot_id] = rs;
+	multisim_num_slots += 1;
+
+	return 0;
+}
+
+static void qcom_msim_radio_settings_remove(struct ofono_radio_settings *rs)
+{
+	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+	int slot_id = ofono_modem_get_integer(rd->modem, "Slot");
+
+	multisim_rs[slot_id] = NULL;
+	multisim_num_slots -= 1;
+
+	ofono_radio_settings_set_data(rs, NULL);
+
+	g_ril_unref(rd->ril);
+	g_free(rd);
+}
+
+static struct ofono_radio_settings_driver driver = {
+	.name			= QCOMMSIMMODEM,
+	.probe			= qcom_msim_radio_settings_probe,
+	.remove			= qcom_msim_radio_settings_remove,
+	.query_rat_mode		= ril_query_rat_mode,
+	.set_rat_mode		= qcom_msim_set_rat_mode,
+	.query_fast_dormancy	= ril_query_fast_dormancy,
+	.set_fast_dormancy	= ril_set_fast_dormancy,
+	.query_modem_rats	= ril_query_modem_rats
+};
+
+void qcom_msim_radio_settings_init(void)
+{
+	ofono_radio_settings_driver_register(&driver);
+}
+
+void qcom_msim_radio_settings_exit(void)
+{
+	ofono_radio_settings_driver_unregister(&driver);
+}

=== modified file 'drivers/rilmodem/gprs-context.c'
--- drivers/rilmodem/gprs-context.c	2015-05-20 16:32:09 +0000
+++ drivers/rilmodem/gprs-context.c	2015-07-02 17:01:42 +0000
@@ -46,6 +46,10 @@
 
 #include "gprs.h"
 #include "rilmodem.h"
+#include "drivers/mtkmodem/mtkutil.h"
+
+#define NUM_DEACTIVATION_RETRIES 4
+#define TIME_BETWEEN_DEACT_RETRIES_S 2
 
 enum state {
 	STATE_IDLE,
@@ -56,18 +60,23 @@
 
 struct gprs_context_data {
 	GRil *ril;
+	struct ofono_modem *modem;
+	unsigned vendor;
 	gint active_ctx_cid;
 	gint active_rild_cid;
 	enum state state;
 	guint call_list_id;
 	char *apn;
 	enum ofono_gprs_context_type type;
+	int deact_retries;
 };
 
 static void ril_gprs_context_deactivate_primary(struct ofono_gprs_context *gc,
 						unsigned int id,
 						ofono_gprs_context_cb_t cb,
 						void *data);
+static void ril_deactivate_data_call_cb(struct ril_msg *message,
+					gpointer user_data);
 
 static void set_context_disconnected(struct gprs_context_data *gcd)
 {
@@ -318,6 +327,52 @@
 	}
 }
 
+static gboolean reset_modem(gpointer data)
+{
+	mtk_reset_modem(data);
+
+	return FALSE;
+}
+
+static gboolean retry_deactivate(gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_gprs_context_cb_t cb = cbd->cb;
+	struct ofono_gprs_context *gc = cbd->user;
+	struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);
+	struct req_deactivate_data_call request;
+	struct parcel rilp;
+	struct ofono_error error;
+
+	/* We might have received a call list update while waiting */
+	if (gcd->state == STATE_IDLE) {
+		if (cb)
+			CALLBACK_WITH_SUCCESS(cb, cbd->data);
+
+		g_free(cbd);
+
+		return FALSE;
+	}
+
+	request.cid = gcd->active_rild_cid;
+	request.reason = RIL_DEACTIVATE_DATA_CALL_NO_REASON;
+
+	g_ril_request_deactivate_data_call(gcd->ril, &request, &rilp, &error);
+
+	if (g_ril_send(gcd->ril, RIL_REQUEST_DEACTIVATE_DATA_CALL, &rilp,
+			ril_deactivate_data_call_cb, cbd, g_free) == 0) {
+
+		ofono_error("%s: send DEACTIVATE_DATA_CALL failed for apn: %s",
+				__func__, gcd->apn);
+		if (cb)
+			CALLBACK_WITH_FAILURE(cb, cbd->data);
+
+		g_free(cbd);
+	}
+
+	return FALSE;
+}
+
 static void ril_deactivate_data_call_cb(struct ril_msg *message,
 					gpointer user_data)
 {
@@ -329,7 +384,6 @@
 
 	DBG("*gc: %p", gc);
 
-	/* Reply has no data... */
 	if (message->error == RIL_E_SUCCESS) {
 
 		g_ril_print_response_no_args(gcd->ril, message);
@@ -337,9 +391,9 @@
 		active_ctx_cid = gcd->active_ctx_cid;
 		set_context_disconnected(gcd);
 
-		/* If the deactivate was a result of a shutdown,
-		 * there won't be call back, so _deactivated()
-		 * needs to be called directly.
+		/*
+		 * If the deactivate was a result of a shutdown, there won't be
+		 * call back, so _deactivated() needs to be called directly.
 		 */
 		if (cb)
 			CALLBACK_WITH_SUCCESS(cb, cbd->data);
@@ -351,8 +405,31 @@
 				__func__, gcd->apn,
 				ril_error_to_string(message->error));
 
-		if (cb)
-			CALLBACK_WITH_FAILURE(cb, cbd->data);
+		/*
+		 * It has been detected that some modems fail the deactivation
+		 * temporarily. We do retries to handle that case.
+		 */
+		if (--(gcd->deact_retries) > 0) {
+			struct cb_data *cbd2;
+
+			cbd2 = cb_data_new(cb, cbd->data, gc);
+			g_timeout_add_seconds(TIME_BETWEEN_DEACT_RETRIES_S,
+							retry_deactivate, cbd2);
+		} else {
+			ofono_error("%s: retry limit hit", __func__);
+
+			if (cb)
+				CALLBACK_WITH_FAILURE(cb, cbd->data);
+
+			/*
+			 * Reset modem if MTK. TODO Failures deactivating a
+			 * context have not been reported for other modems, but
+			 * it would be good to have a generic method to force an
+			 * internal reset nonetheless.
+			 */
+			if (gcd->vendor == OFONO_RIL_VENDOR_MTK)
+				g_idle_add(reset_modem, gcd->modem);
+		}
 	}
 }
 
@@ -402,6 +479,7 @@
 		goto error;
 	}
 
+	gcd->deact_retries = NUM_DEACTIVATION_RETRIES;
 	ret = g_ril_send(gcd->ril, RIL_REQUEST_DEACTIVATE_DATA_CALL, &rilp,
 				ril_deactivate_data_call_cb, cbd, g_free);
 
@@ -438,6 +516,8 @@
 		return -ENOMEM;
 
 	gcd->ril = g_ril_clone(ril_data->gril);
+	gcd->modem = ril_data->modem;
+	gcd->vendor = vendor;
 	set_context_disconnected(gcd);
 	gcd->call_list_id = -1;
 	gcd->type = ril_data->type;

=== modified file 'drivers/rilmodem/radio-settings.c'
--- drivers/rilmodem/radio-settings.c	2015-01-29 14:50:30 +0000
+++ drivers/rilmodem/radio-settings.c	2015-07-02 17:01:42 +0000
@@ -229,7 +229,7 @@
 	return FALSE;
 }
 
-static void ril_query_modem_rats(struct ofono_radio_settings *rs,
+void ril_query_modem_rats(struct ofono_radio_settings *rs,
 				ofono_radio_settings_modem_rats_query_cb_t cb,
 				void *data)
 {

=== modified file 'drivers/rilmodem/radio-settings.h'
--- drivers/rilmodem/radio-settings.h	2015-01-29 14:50:30 +0000
+++ drivers/rilmodem/radio-settings.h	2015-07-02 17:01:42 +0000
@@ -42,3 +42,6 @@
 				ofono_bool_t enable,
 				ofono_radio_settings_fast_dormancy_set_cb_t cb,
 				void *data);
+void ril_query_modem_rats(struct ofono_radio_settings *rs,
+				ofono_radio_settings_modem_rats_query_cb_t cb,
+				void *data);

=== modified file 'drivers/rilmodem/rilutil.h'
--- drivers/rilmodem/rilutil.h	2015-01-29 14:50:30 +0000
+++ drivers/rilmodem/rilutil.h	2015-07-02 17:01:42 +0000
@@ -75,6 +75,7 @@
 
 struct ril_gprs_context_data {
 	GRil *gril;
+	struct ofono_modem *modem;
 	enum ofono_gprs_context_type type;
 };
 

=== modified file 'gril/gril.c'
--- gril/gril.c	2014-09-22 16:06:53 +0000
+++ gril/gril.c	2015-07-02 17:01:42 +0000
@@ -272,9 +272,6 @@
 		return NULL;
 	}
 
-	DBG("req: %s, id: %d, data_len: %u",
-		request_id_to_string(ril, req), id, data_len);
-
 	/* Full request size: header size plus buffer length */
 	r->data_len = data_len + sizeof(header);
 
@@ -375,9 +372,6 @@
 	for (i = 0; i < count; i++) {
 		req = g_queue_peek_nth(p->command_queue, i);
 
-		DBG("comparing req->id: %d to message->serial_no: %d",
-			req->id, message->serial_no);
-
 		if (req->id == message->serial_no) {
 			found = TRUE;
 			message->req = req->req;
@@ -393,7 +387,7 @@
 				req->callback(message, req->user_data);
 
 			len = g_queue_get_length(p->out_queue);
-			DBG("requests in out_queue before removing: %d", len);
+
 			for (i = 0; i < len; i++) {
 				id = GPOINTER_TO_INT(g_queue_peek_nth(
 							p->out_queue, i));
@@ -413,7 +407,7 @@
 	}
 
 	if (found == FALSE)
-		DBG("Reply: %s serial_no: %d without a matching request!",
+		ofono_error("No matching request for reply: %s serial_no: %d!",
 			request_id_to_string(p, message->req),
 			message->serial_no);
 
@@ -584,11 +578,8 @@
 	*/
 
 	message_len = *len - 4;
-	if (message_len < plen) {
-		DBG("Not enough bytes for fixed record; len: %d avail: %d",
-			plen, message_len);
+	if (message_len < plen)
 		return NULL;
-	}
 
 	/* FIXME: add check for message_len = 0? */
 
@@ -738,7 +729,7 @@
 	len = req->data_len;
 
 	towrite = len - ril->req_bytes_written;
-	DBG("req:%d,len:%zu,towrite:%zu", req->id, len, towrite);
+
 #ifdef WRITE_SCHEDULER_DEBUG
 	if (towrite > 5)
 		towrite = 5;
@@ -1168,8 +1159,6 @@
 
 	g_queue_push_tail(p->command_queue, r);
 
-	DBG("calling wakeup_writer: command_queue len: %d",
-		g_queue_get_length(p->command_queue));
 	ril_wakeup_writer(p);
 
 	if (rilp == NULL)

=== added file 'include/dns-client.h'
--- include/dns-client.h	1970-01-01 00:00:00 +0000
+++ include/dns-client.h	2015-07-02 17:01:42 +0000
@@ -0,0 +1,120 @@
+/*
+ *
+ *  DNS Client - provides an asynchronous DNS resolution client.
+ *
+ *  This file originally created by Google, Inc.
+ *  Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
+ *  Copyright (c) 2015 Canonical Ltd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef OFONO_DNS_CLIENT_H
+#define OFONO_DNS_CLIENT_H
+
+struct sockaddr;
+
+/**
+ * SECTION:dns_client
+ * @title: DNS client interface
+ * @short_description: Functions for interacting with asynchronous DNS client
+ */
+
+/*
+ * Enumeration of possible DNS request completion status codes.
+ * These are intentionally consistent with shill error codes.
+ */
+typedef enum {
+	OFONO_DNS_CLIENT_SUCCESS = 0,
+	OFONO_DNS_CLIENT_ERROR_NO_DATA,
+	OFONO_DNS_CLIENT_ERROR_FORM_ERR,
+	OFONO_DNS_CLIENT_ERROR_SERVER_FAIL,
+	OFONO_DNS_CLIENT_ERROR_NOT_FOUND,
+	OFONO_DNS_CLIENT_ERROR_NOT_IMP,
+	OFONO_DNS_CLIENT_ERROR_REFUSED,
+	OFONO_DNS_CLIENT_ERROR_BAD_QUERY,
+	OFONO_DNS_CLIENT_ERROR_NET_REFUSED,
+	OFONO_DNS_CLIENT_ERROR_TIMED_OUT,
+	OFONO_DNS_CLIENT_ERROR_UNKNOWN,
+} ofono_dns_client_status_t;
+
+/*
+ * Callbacks of this type are provided by a client when initiating a DNS request
+ * and invoked by the dns_client module when a request has completed.
+ * |data| is user data supplied by the client.
+ * |status| is the completion status of the request.
+ * |ip_addr| is a struct sockaddr containing an  IPv4 or IPv6 address if the
+ * request succeeded and NULL otherwise. The callee should copy |ip_addr| if it
+ * wishes to retain it beyond the lifetime of this callback.
+ */
+typedef void (*ofono_dns_client_callback_t)(void *data,
+					ofono_dns_client_status_t status,
+					struct sockaddr *ip_addr);
+
+/*
+ * Opaque handle uniquely indentifying an in-progress request.
+ */
+typedef void *ofono_dns_client_request_t;
+
+struct ofono_dns_client_driver {
+	const char *name;
+	ofono_dns_client_request_t (*submit_request)(const char *hostname,
+						const char *device,
+						const char **servers,
+						int timeout_ms,
+						ofono_dns_client_callback_t cb,
+						void *data);
+	gboolean (*cancel_request)(ofono_dns_client_request_t request);
+};
+
+
+/*
+ * Initiate an asynchronous name resolution request for |hostname|.
+ * |device| specifies the interface out which the request should be sent, or
+ * NULL to use the default interface.
+ * |servers| string array with name servers to query or NULL to use system
+ * defaults
+ * |timeout_ms| specifies a max timeout in milliseconds, or 0 to use the default
+ * timeout (which depends on the plugin).
+ * Returns an opaque handle identifying the request on success and NULL on
+ * failure. Success indicates only that the request was initiated, not that the
+ * request itself was successful.
+ * When the request is complete, the callback |cb| will be invoked with |data|
+ * passed as an arg.
+ */
+ofono_dns_client_request_t __ofono_dns_client_submit_request(
+						const char *hostname,
+						const char *device,
+						const char **servers,
+						int timeout_ms,
+						ofono_dns_client_callback_t cb,
+						void *data);
+
+/*
+ * Cancel the request identified by |request|. Does not invoke the callback for
+ * the cancelled request.
+ */
+void __ofono_dns_client_cancel_request(ofono_dns_client_request_t request);
+
+/*
+ * Returns a human-friendly error string corresponding to |status|.
+ */
+const char *__ofono_dns_client_strerror(ofono_dns_client_status_t status);
+
+int ofono_dns_client_driver_register(struct ofono_dns_client_driver *driver);
+void ofono_dns_client_driver_unregister(
+				const struct ofono_dns_client_driver *driver);
+
+#endif /* OFONO_DNS_CLIENT_H */

=== modified file 'include/radio-settings.h'
--- include/radio-settings.h	2014-07-24 08:31:17 +0000
+++ include/radio-settings.h	2015-07-02 17:01:42 +0000
@@ -136,6 +136,9 @@
 void ofono_radio_settings_set_data(struct ofono_radio_settings *rs, void *data);
 void *ofono_radio_settings_get_data(struct ofono_radio_settings *rs);
 
+void ofono_radio_settings_set_rat_mode(struct ofono_radio_settings *rs,
+					enum ofono_radio_access_mode mode);
+
 #ifdef __cplusplus
 }
 #endif

=== added file 'plugins/c-ares-dns-client.c'
--- plugins/c-ares-dns-client.c	1970-01-01 00:00:00 +0000
+++ plugins/c-ares-dns-client.c	2015-07-02 17:01:42 +0000
@@ -0,0 +1,767 @@
+/*
+ *
+ *  DNS Client - provides an asynchronous DNS resolution client.
+ *
+ *  The client is implemented using the c-ares library, and integrates with
+ *  glib's main event loop. It was originally written to be used by flimflam,
+ *  and it has been modified to integrate with ofono.  See http://c-ares.haxx.se
+ *  and http://developer.gnome.org/glib for c-ares and glib documentation.
+ *
+ *  This file originally created by Google, Inc.
+ *  Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
+ *  Copyright (c) 2015 Canonical Ltd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/time.h>
+
+#include <ares.h>
+#include <glib.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+#include <ofono/types.h>
+#include <ofono/log.h>
+#include <ofono/plugin.h>
+#include <ofono/modem.h>
+#include <ofono/dns-client.h>
+
+/* Structure representing a pending asynchronous name resolution request. */
+struct ares_request {
+	char *hostname;  /* hostname that we're resolving */
+	char *interface; /* interface to use for queries */
+	struct ares_addr_node *servers;
+	struct timeval timeout;  /* caller-specified timeout */
+	struct timeval start_time;  /* time at which request was started */
+	ofono_dns_client_callback_t cb;  /* client-provided callback */
+	void *data;  /* user data */
+	ares_channel channel;  /* opaque, used by c-ares library */
+	GHashTable *ares_watches;  /* fds that we're monitoring for c-ares */
+	guint timeout_source_id;  /* glib source id for our ares timeout */
+	gboolean running;  /* stopped requests are eligible for deletion */
+};
+
+/*
+ * Structure representing a file descriptor that we're monitoring within our
+ * glib event loop for c-ares.
+ */
+struct ares_watch {
+	struct ares_request *request;  /* backpointer to our owner */
+	int fd;	 /* file descriptor that we're watching */
+	GIOChannel *gio_channel;  /* glib IO channel */
+	GIOCondition gio_condition;  /* events in which we're interested */
+	guint g_source_id;  /* glib source id */
+};
+
+/*
+ * List of pending asynchronous name resolution requests. We expect the number
+ * of pending requests to be small, hence the use of a linked list.
+ */
+static GList *pending_requests = NULL;
+
+/*
+ * ares requests are often stopped from within ares callbacks. In these cases,
+ * we defer deletion of the ares_request struct to the idle loop. This is the
+ * glib source id associated with the deferred deletion task.
+ */
+static guint deferred_deletion_g_source_id = 0;
+
+static void reset_ares_timeout(struct ares_request *request,
+			       gboolean destroy_old_source);
+static void stop_ares_request(struct ares_request *request);
+
+/*#define USE_RP_FILTER*/
+
+/*
+ * Set/unset reverse path filtering (from connman). Using this should make
+ * setting routes for the DNS servers unnecessary, but unfortunately that is not
+ * happening.
+ * TODO Investigate why this is not working.
+ */
+#ifdef USE_RP_FILTER
+static void rp_filter_set(const char *interface, gboolean enabled)
+{
+	int fd;
+	ssize_t cnt;
+	char filename[PATH_MAX];
+	const char *str_value = (enabled == TRUE) ? "1" : "0";
+
+	snprintf(filename, sizeof(filename),
+			"/proc/sys/net/ipv4/conf/%s/rp_filter", interface);
+	fd = open(filename, O_WRONLY);
+	if (fd == -1)
+		return;
+	cnt = write(fd, str_value, strlen(str_value));
+	if (cnt == -1)
+		ofono_error("%s: cannot write (%s)", __func__, strerror(errno));
+	close(fd);
+}
+#else
+static void rp_filter_set(const char *interface, gboolean enabled)
+{
+}
+#endif
+
+/*
+ * Callback invoked when it's time to give control back to c-ares. Controlled by
+ * the glib source referred to by |timeout_source_id| in struct ares_request.
+ */
+static gboolean ares_timeout_cb(gpointer data)
+{
+	struct ares_request *request = data;
+	const gboolean destroy_old_source = FALSE;
+
+	DBG("request %p: running = %d", request, request->running);
+
+	if (!request->running) {
+		request->timeout_source_id = 0;
+		return FALSE;
+	}
+
+	ares_process_fd(request->channel, ARES_SOCKET_BAD, ARES_SOCKET_BAD);
+
+	/*
+	 * NOTE: We tell reset_ares_timeout not to destroy its old timer source
+	 * because we're calling it from within that source and it will be
+	 * destroyed by glib when we return FALSE below.
+	 */
+	reset_ares_timeout(request, destroy_old_source);
+
+	/*
+	 * Return FALSE to get rid of our old glib source. We created a new
+	 * one during our call to reset_ares_timeout above.
+	 */
+	return FALSE;
+}
+
+/*
+ * Determine how long c-ares is willing to wait until being given control and
+ * schedule ares_timeout_cb to be invoked at that time. Any existing
+ * timer is replaced. If |destroy_old_source| is TRUE, the old timer's glib
+ * source will be destroyed.
+ */
+static void reset_ares_timeout(struct ares_request *request,
+			       gboolean destroy_old_source)
+{
+	struct timeval ret_tv, now, elapsed, max_tv;
+	struct timeval *tv;
+	struct timeval *max = NULL;
+	guint timeout_interval_msecs = 0;
+	gboolean timeout_provided = FALSE;
+
+	DBG("request %p: running = %d", request, request->running);
+
+	if (!request->running)
+		return;
+
+	/*
+	 * Compute how much time has elapsed since the request started.
+	 * If the client provided a non-default timeout and we've timed out,
+	 * notify the client and stop the request.
+	 */
+	gettimeofday(&now, NULL);
+	timersub(&now, &request->start_time, &elapsed);
+	timeout_provided = request->timeout.tv_sec != 0 ||
+			   request->timeout.tv_usec != 0;
+	if (timeout_provided && timercmp(&elapsed, &request->timeout, >=)) {
+		request->cb(request->data, OFONO_DNS_CLIENT_ERROR_TIMED_OUT,
+			    NULL);
+		stop_ares_request(request);
+		return;
+	}
+
+	/*
+	 * Tell c-ares how long we're willing to wait (max) and see if it wants
+	 * to regain control sooner than that.
+	 */
+	if (timeout_provided) {
+		timersub(&request->timeout, &elapsed, &max_tv);
+		max = &max_tv;
+	}
+	if ((tv = ares_timeout(request->channel, max, &ret_tv)) == NULL) {
+		ofono_error("%s: ares_timeout failed", __func__);
+		return;
+	}
+
+	/*
+	 * Reschedule our timeout to be the sooner of the ares-specified tiemout
+	 * and the client-specified timeout.
+	 */
+	if (request->timeout_source_id != 0 && destroy_old_source) {
+		if (!g_source_remove(request->timeout_source_id))
+			ofono_error("%s: g_source_remove failed", __func__);
+	}
+
+	timeout_interval_msecs = tv->tv_sec * 1000 + tv->tv_usec / 1000;
+	DBG("timeout interval = %u", timeout_interval_msecs);
+
+	request->timeout_source_id = g_timeout_add(timeout_interval_msecs,
+							ares_timeout_cb,
+							request);
+}
+
+/*
+ * Callback invoked by glib when there is activity on a file descriptor that
+ * we're monitoring for c-ares.
+ */
+static gboolean ares_watch_io_cb(GIOChannel *source,
+				 GIOCondition condition,
+				 gpointer data)
+{
+	struct ares_watch *watch = data;
+	ares_socket_t read_fd = ARES_SOCKET_BAD;
+	ares_socket_t write_fd = ARES_SOCKET_BAD;
+	const gboolean destroy_old_source = TRUE;
+
+	DBG("watch %p (fd %d): condition = 0x%x", watch, watch->fd,
+			condition);
+
+	if (!watch->request->running) {
+		/* Destroy this source by returning FALSE. */
+		watch->g_source_id = 0;
+		return FALSE;
+	}
+
+	if (condition & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
+		ofono_error("%s: error condition on fd %d", __func__,
+			      watch->fd);
+		watch->g_source_id = 0;
+		return FALSE;
+	}
+
+	if (condition & G_IO_IN)
+		read_fd = watch->fd;
+	if (condition & G_IO_OUT)
+		write_fd = watch->fd;
+
+	/* Give control to c-ares. */
+	ares_process_fd(watch->request->channel, read_fd, write_fd);
+
+	reset_ares_timeout(watch->request, destroy_old_source);
+
+	return TRUE;
+}
+
+/*
+ * Destroy an ares_watch structure. We register this as our value destroy
+ * function when creating the ares_watches table, and it is called by glib
+ * whenever we remove a value from the table or destroy the table.
+ */
+static void destroy_ares_watch(gpointer data)
+{
+	struct ares_watch *watch = data;
+
+	DBG("watch %p (fd %d)", watch, watch->fd);
+
+	if (watch->g_source_id != 0) {
+		if (!g_source_remove(watch->g_source_id)) {
+			ofono_error("%s: g_source_remove failed for id %d",
+					__func__, watch->g_source_id);
+		}
+		watch->g_source_id = 0;
+	}
+
+	g_io_channel_unref(watch->gio_channel);
+	g_free(watch);
+}
+
+/*
+ * Create an ares_watch for |fd| and store it in the ares_watches table for
+ * |request|. Monitor for readability if |read| is TRUE. Monitor for writability
+ * if |write| is TRUE. If there is already an entry for |fd| in the table,
+ * update it according to the values of |read| and |write|.
+ */
+static gboolean init_ares_watch(struct ares_request *request, int fd,
+				gboolean read, gboolean write)
+{
+	struct ares_watch *watch;
+
+	DBG("fd = %d, read = %d, write = %d", fd, read, write);
+
+	/*
+	 * If there's an old watch in the table, destroy it. We'll replace it
+	 * with a new one below if c-ares is still interested in this fd.
+	 */
+	if (g_hash_table_lookup(request->ares_watches, &fd) != NULL) {
+		/* This removal calls destroy_ares_watch on the old watch. */
+		g_hash_table_remove(request->ares_watches, &fd);
+	}
+
+	if (!read && !write)
+		return TRUE;
+
+	watch = g_malloc0(sizeof(struct ares_watch));
+
+	watch->request = request;
+	watch->fd = fd;
+	watch->g_source_id = 0;
+
+	watch->gio_condition = G_IO_NVAL | G_IO_HUP | G_IO_ERR;
+	if (read)
+		watch->gio_condition |= G_IO_IN;
+	if (write)
+		watch->gio_condition |= G_IO_OUT;
+
+	watch->gio_channel = g_io_channel_unix_new(fd);
+	if (watch->gio_channel == NULL) {
+		ofono_error("%s: could not create g_io_channel for fd %d",
+								__func__, fd);
+		g_free(watch);
+		return FALSE;
+	}
+	g_io_channel_set_close_on_unref(watch->gio_channel, FALSE);
+
+	g_hash_table_insert(request->ares_watches, &fd, watch);
+
+	watch->g_source_id = g_io_add_watch(watch->gio_channel,
+					    watch->gio_condition,
+					    ares_watch_io_cb,
+					    watch);
+
+	return TRUE;
+}
+
+/*
+ * Destroy an ares_request struct, freeing the resources allocated in
+ * init_ares_request. |request| must already have been removed from the
+ * |pending_requests| list and must have been marked not running.
+ */
+static void destroy_ares_request(struct ares_request *request)
+{
+	struct ares_addr_node *node, *next;
+
+	DBG("request %p", request);
+
+	ares_destroy(request->channel);
+	g_free(request->hostname);
+	if (request->interface) {
+		rp_filter_set(request->interface, TRUE);
+		g_free(request->interface);
+	}
+	for (node = request->servers; node != NULL; node = next) {
+		next = node->next;
+		g_free(node);
+	}
+	if (request->timeout_source_id != 0)
+		g_source_remove(request->timeout_source_id);
+	/* Hash table destruction calls destroy_ares_watch on all watches. */
+	g_hash_table_destroy(request->ares_watches);
+	g_free(request);
+}
+
+/*
+ * Callback invoked from the main loop to perform deferred deletion of stopped
+ * ares_request objects. We do deferred deletion to avoid problems when we're in
+ * an ares callback and want to delete an object that contains context
+ * associated with that callback.
+ */
+static gboolean delete_stopped_ares_requests_cb(gpointer data)
+{
+	GList *node, *next;
+	struct ares_request *request;
+	guint num_requests_deleted = 0;
+
+	DBG("pending_requests list has length %u",
+			g_list_length(pending_requests));
+
+	/*
+	 * Inspect each request in |pending_requests| and destroy it if it's
+	 * not running.
+	 */
+	for (node = pending_requests; node != NULL; node = next) {
+		next = g_list_next(node);
+		request = node->data;
+		if (!request->running) {
+			pending_requests = g_list_delete_link(pending_requests,
+							      node);
+			destroy_ares_request(request);
+			++num_requests_deleted;
+		}
+	}
+	DBG("deleted %u stopped requests", num_requests_deleted);
+
+	deferred_deletion_g_source_id = 0;
+	return FALSE;
+}
+
+/*
+ * Stop an ares_request and schedule the deferred deletion task if it's
+ * not already running.
+ */
+static void stop_ares_request(struct ares_request *request)
+{
+	DBG("");
+
+	request->running = FALSE;
+
+	if (deferred_deletion_g_source_id != 0)
+		return;
+
+	deferred_deletion_g_source_id =
+	    g_idle_add(delete_stopped_ares_requests_cb, NULL);
+	if (deferred_deletion_g_source_id == 0)
+		ofono_error("%s: g_idle_add failed", __func__);
+}
+
+/*
+ * Callback that is invoked by c-ares to tell us which sockets it wants us to
+ * monitor for readability and writability.
+ */
+static void ares_socket_state_cb(void *data, int s, int read, int write)
+{
+	struct ares_request *request = (struct ares_request *) data;
+
+	DBG("");
+
+	if (!request->running)
+		return;
+
+	DBG("socket %d: read = %d, write = %d", s, read, write);
+
+	if (!init_ares_watch(request, s, read, write))
+		ofono_error("%s: couldn't create ares_watch for socket %d",
+			      __func__, s);
+}
+
+/*
+ * Converts a c-ares status code to the corresponding dns_client status code.
+ * We do this to completely encapsulate c-ares. In theory, we should be able to
+ * replace it with a different asynchronous DNS library without changing our
+ * clients.
+ */
+static ofono_dns_client_status_t status_from_ares_status(int ares_status)
+{
+	switch(ares_status) {
+	case ARES_SUCCESS:
+		return OFONO_DNS_CLIENT_SUCCESS;
+	case ARES_ENODATA:
+		return OFONO_DNS_CLIENT_ERROR_NO_DATA;
+	case ARES_EFORMERR:
+		return OFONO_DNS_CLIENT_ERROR_FORM_ERR;
+	case ARES_ESERVFAIL:
+		return OFONO_DNS_CLIENT_ERROR_SERVER_FAIL;
+	case ARES_ENOTFOUND:
+		return OFONO_DNS_CLIENT_ERROR_NOT_FOUND;
+	case ARES_ENOTIMP:
+		return OFONO_DNS_CLIENT_ERROR_NOT_IMP;
+	case ARES_EREFUSED:
+		return OFONO_DNS_CLIENT_ERROR_REFUSED;
+	case ARES_EBADQUERY:
+	case ARES_EBADNAME:
+	case ARES_EBADFAMILY:
+	case ARES_EBADRESP:
+		return OFONO_DNS_CLIENT_ERROR_BAD_QUERY;
+	case ARES_ECONNREFUSED:
+		return OFONO_DNS_CLIENT_ERROR_NET_REFUSED;
+	case ARES_ETIMEOUT:
+		return OFONO_DNS_CLIENT_ERROR_TIMED_OUT;
+	default:
+		return OFONO_DNS_CLIENT_ERROR_UNKNOWN;
+	}
+}
+
+/*
+ * Callback that is invoked by c-ares when an asynchronous name resolution
+ * request that we have previously initiated is complete.
+ */
+static void ares_request_cb(void *arg, int ares_status, int timeouts,
+			    struct hostent *hostent)
+{
+	struct sockaddr_in sin;
+	struct sockaddr_in6 sin6;
+	int addr_length;
+	void *addr_buffer;
+	char ip_addr_string[INET6_ADDRSTRLEN];
+	struct sockaddr *ip_addr;
+	struct ares_request *request = (struct ares_request *)arg;
+
+	DBG("");
+
+	if (!request->running)
+		return;
+
+	/* Stop the request. It will be deleted later from the idle loop. */
+	stop_ares_request(request);
+
+	if (ares_status != ARES_SUCCESS) {
+		DBG("ares request for '%s' failed: %s",
+				request->hostname, ares_strerror(ares_status));
+		/* Notify client. */
+		request->cb(request->data, status_from_ares_status(ares_status),
+				NULL);
+		return;
+	}
+
+	if (hostent->h_addrtype != AF_INET && hostent->h_addrtype != AF_INET6) {
+		ofono_error("%s: unsupported addrtype: %d",
+				__func__, hostent->h_addrtype);
+		request->cb(request->data, OFONO_DNS_CLIENT_ERROR_NO_DATA,
+				NULL);
+		return;
+	}
+
+	if (hostent->h_addrtype == AF_INET) {
+		memset(&sin, 0, sizeof(sin));
+		sin.sin_family = AF_INET;
+		addr_length = sizeof(sin.sin_addr.s_addr);
+		addr_buffer = &sin.sin_addr.s_addr;
+		ip_addr = (struct sockaddr *) &sin;
+	} else {  /* AF_INET6 */
+		memset(&sin6, 0, sizeof(sin6));
+		sin6.sin6_family = AF_INET6;
+		addr_length = sizeof(sin6.sin6_addr.s6_addr);
+		addr_buffer = &sin6.sin6_addr.s6_addr;
+		ip_addr = (struct sockaddr *) &sin6;
+	}
+
+	if (hostent->h_length > addr_length) {
+		ofono_error("%s: address too large: %u bytes",
+				__func__, hostent->h_length);
+		request->cb(request->data, OFONO_DNS_CLIENT_ERROR_NO_DATA,
+				NULL);
+		return;
+	}
+
+	memcpy(addr_buffer, hostent->h_addr, hostent->h_length);
+
+	if (inet_ntop(hostent->h_addrtype, addr_buffer, ip_addr_string,
+			sizeof(ip_addr_string)) == NULL) {
+		ofono_error("%s: could not convert address to string: %s",
+				__func__, strerror(errno));
+		request->cb(request->data, OFONO_DNS_CLIENT_ERROR_NO_DATA,
+				NULL);
+		return;
+	}
+
+	DBG("ares request for '%s' succeeded with %d timeouts: %s",
+			request->hostname, timeouts, ip_addr_string);
+	request->cb(request->data, status_from_ares_status(ares_status),
+			ip_addr);
+}
+
+/* Cancel all in-progress asynchronous name resolution requests. */
+static void cancel_all_ares_requests()
+{
+	GList *node;
+	struct ares_request *request;
+
+	DBG("");
+
+	while ((node = g_list_first(pending_requests)) != NULL) {
+		request = node->data;
+		pending_requests = g_list_delete_link(pending_requests, node);
+		request->running = FALSE;  /* don't trip assertion */
+		destroy_ares_request(request);
+	}
+}
+
+static void set_request_servers(const char **servers,
+						struct ares_request *request)
+{
+	struct ares_addr_node *current;
+	struct ares_addr_node **prev = &request->servers;
+	const char **dns;
+	int rc;
+
+	for (dns = servers; *dns != NULL; ++dns) {
+		current = g_malloc0(sizeof(*current));
+		rc = inet_pton(AF_INET, *dns, &current->addr.addr4);
+		if (rc == 1) {
+			current->family = AF_INET;
+		} else {
+			rc = inet_pton(AF_INET6, *dns, &current->addr.addr6);
+			if (rc != 1) {
+				ofono_error("%s: wrong dns address %s",
+								__func__, *dns);
+				g_free(current);
+				continue;
+			}
+			current->family = AF_INET6;
+		}
+
+		*prev = current;
+		prev = &current->next;
+	}
+}
+
+/* Initiate an asynchronous name resolution request. */
+static ofono_dns_client_request_t
+ofono_dns_client_submit_request(const char *hostname,
+				const char *interface,
+				const char **servers,
+				int timeout_ms,
+				ofono_dns_client_callback_t cb,
+				void *data)
+{
+	int ares_status;
+	struct ares_request *request;
+	struct ares_options options;
+	int optmask;
+	const gboolean destroy_old_source = TRUE;
+
+	DBG("");
+
+	if (timeout_ms < 0) {
+		DBG("invalid timeout value of %d ms", timeout_ms);
+		return NULL;
+	}
+
+	request = g_malloc0(sizeof(struct ares_request));
+	request->running = TRUE;
+
+	request->ares_watches = g_hash_table_new_full(g_int_hash, g_int_equal,
+						NULL, destroy_ares_watch);
+	if (request->ares_watches == NULL) {
+		ofono_error("%s: could not create ares_watches table",
+								__func__);
+		g_free(request);
+		return NULL;
+	}
+
+	/*
+	 * Init a c-ares channel for this request. We set an option asking
+	 * c-ares to notify us via callback about which sockets it wants to
+	 * monitor for readability and writability. This allows us to
+	 * integrate c-ares activity into our glib main event loop.
+	 */
+	memset(&options, 0, sizeof(options));
+	options.sock_state_cb = ares_socket_state_cb;
+	options.sock_state_cb_data = request;
+	optmask = ARES_OPT_SOCK_STATE_CB;
+	if (timeout_ms > 0) {
+		options.timeout = timeout_ms;
+		optmask |= ARES_OPT_TIMEOUTMS;
+	}
+	ares_status = ares_init_options(&request->channel, &options, optmask);
+	if (ares_status != ARES_SUCCESS) {
+		ofono_error("%s: failed to init c-ares channel: %s", __func__,
+				ares_strerror(ares_status));
+		request->running = FALSE;  /* don't trip assertion */
+		g_hash_table_destroy(request->ares_watches);
+		g_free(request);
+		return NULL;
+	}
+
+	if (servers != NULL) {
+		set_request_servers(servers, request);
+		ares_status =
+			ares_set_servers(request->channel, request->servers);
+		/* Log an error, but continue anyway */
+		if (ares_status != ARES_SUCCESS)
+			ofono_error("%s: failed to set name servers: %s",
+					__func__, ares_strerror(ares_status));
+	}
+
+	/*
+	 * If the caller has provided a preferred interface, tell c-ares to
+	 * send requests out that interface, and unset rf filter.
+	 */
+	if (interface != NULL) {
+		DBG("caller has specified device %s", interface);
+
+		request->interface = g_strdup(interface);
+		ares_set_local_dev(request->channel, request->interface);
+		rp_filter_set(request->interface, FALSE);
+	}
+
+	request->cb = cb;
+	request->data = data;
+	request->hostname = g_strdup(hostname);
+	request->timeout.tv_sec = timeout_ms / 1000;
+	request->timeout.tv_usec = (timeout_ms % 1000) * 1000;
+	gettimeofday(&request->start_time, NULL);
+
+	pending_requests = g_list_append(pending_requests, request);
+
+	ares_gethostbyname(request->channel, hostname, AF_INET,
+						ares_request_cb, request);
+
+	reset_ares_timeout(request, destroy_old_source);
+
+	return request;
+}
+
+/* Cancel an in-progress name resolution request. */
+static gboolean ofono_dns_client_cancel_request(ofono_dns_client_request_t req)
+{
+	struct ares_request *request = req;
+
+	if (request == NULL || g_list_find (pending_requests, request) == NULL)
+		return FALSE;
+
+	DBG("request %p", request);
+
+	if (!request->running)
+		return TRUE;
+
+	pending_requests = g_list_remove(pending_requests, request);
+	request->running = FALSE;  /* don't trip assertion */
+	destroy_ares_request(request);
+
+	return TRUE;
+}
+
+static struct ofono_dns_client_driver dns_driver = {
+	.name		= "c-ares DNS client",
+	.submit_request	= ofono_dns_client_submit_request,
+	.cancel_request = ofono_dns_client_cancel_request
+};
+
+/* Intitialize this module. */
+static int c_ares_init(void)
+{
+	int ares_status = 0;
+	DBG("");
+	ares_status = ares_library_init(ARES_LIB_INIT_ALL);
+	if (ares_status != ARES_SUCCESS) {
+		ofono_error("%s: Failed to init c-ares: %s", __func__,
+				ares_strerror(ares_status));
+		return -1;
+	}
+	return ofono_dns_client_driver_register(&dns_driver);
+}
+
+/* Clean up. */
+static void c_ares_exit(void)
+{
+	DBG("");
+
+	ofono_dns_client_driver_unregister(&dns_driver);
+
+	if (deferred_deletion_g_source_id != 0) {
+		g_source_remove(deferred_deletion_g_source_id);
+		deferred_deletion_g_source_id = 0;
+	}
+	cancel_all_ares_requests();
+	ares_library_cleanup();
+}
+
+OFONO_PLUGIN_DEFINE(c_ares_dns_client, "c-ares DNS client", VERSION,
+			OFONO_PLUGIN_PRIORITY_DEFAULT,
+			c_ares_init, c_ares_exit)

=== modified file 'plugins/mtk.c'
--- plugins/mtk.c	2015-04-01 07:04:18 +0000
+++ plugins/mtk.c	2015-07-02 17:01:42 +0000
@@ -830,9 +830,9 @@
 		struct ofono_gprs_context *gc;
 		struct ril_gprs_driver_data gprs_data = { md->ril, modem };
 		struct ril_gprs_context_data inet_ctx =
-			{ md->ril, OFONO_GPRS_CONTEXT_TYPE_INTERNET };
+			{ md->ril, modem, OFONO_GPRS_CONTEXT_TYPE_INTERNET };
 		struct ril_gprs_context_data mms_ctx =
-			{ md->ril, OFONO_GPRS_CONTEXT_TYPE_MMS };
+			{ md->ril, modem, OFONO_GPRS_CONTEXT_TYPE_MMS };
 
 		DBG("SIM ready, creating more atoms");
 
@@ -1347,6 +1347,16 @@
 		mtk_set_online(mtk_data_1->modem, FALSE, set_offline_cb, NULL);
 }
 
+void mtk_reset_modem(struct ofono_modem *modem)
+{
+
+	if (ofono_modem_get_powered(modem) == FALSE)
+		return;
+
+	ofono_modem_set_powered(modem, FALSE);
+	g_idle_add(mtk_connected, modem);
+}
+
 static void create_atoms_on_connection(struct ofono_modem *modem)
 {
 	struct mtk_data *md = ofono_modem_get_data(modem);

=== modified file 'plugins/ril.c'
--- plugins/ril.c	2015-02-04 00:09:22 +0000
+++ plugins/ril.c	2015-07-02 17:01:42 +0000
@@ -63,6 +63,7 @@
 #include "ril.h"
 #include "drivers/rilmodem/rilmodem.h"
 #include "drivers/rilmodem/vendor.h"
+#include "drivers/qcommsimmodem/qcom_msim_modem.h"
 
 #define MAX_SIM_STATUS_RETRIES 15
 
@@ -70,7 +71,8 @@
 #define RILD_MAX_CONNECT_RETRIES 5
 #define RILD_CONNECT_RETRY_TIME_S 5
 
-#define RILD_CMD_SOCKET "/dev/socket/rild"
+char *RILD_CMD_SOCKET[] = {"/dev/socket/rild", "/dev/socket/rild1"};
+char *GRIL_HEX_PREFIX[] = {"Device 0: ", "Device 1: "};
 
 struct ril_data {
 	GRil *ril;
@@ -111,11 +113,19 @@
 		case RADIO_STATE_ON:
 
 			if (rd->radio_settings == NULL) {
+				char *rs_driver;
 				struct ril_radio_settings_driver_data rs_data =
 							{ rd->ril, modem };
+
+				if (rd->vendor == OFONO_RIL_VENDOR_QCOM_MSIM)
+					rs_driver = QCOMMSIMMODEM;
+				else
+					rs_driver = RILMODEM;
+
 				rd->radio_settings =
 					ofono_radio_settings_create(modem,
-						rd->vendor, RILMODEM, &rs_data);
+							rd->vendor, rs_driver,
+							&rs_data);
 			}
 
 			break;
@@ -215,9 +225,9 @@
 	struct ofono_message_waiting *mw;
 	struct ril_gprs_driver_data gprs_data = { rd->ril, modem };
 	struct ril_gprs_context_data inet_ctx =
-			{ rd->ril, OFONO_GPRS_CONTEXT_TYPE_INTERNET };
+			{ rd->ril, modem, OFONO_GPRS_CONTEXT_TYPE_INTERNET };
 	struct ril_gprs_context_data mms_ctx =
-			{ rd->ril, OFONO_GPRS_CONTEXT_TYPE_MMS };
+			{ rd->ril, modem, OFONO_GPRS_CONTEXT_TYPE_MMS };
 
 	/* TODO: this function should setup:
 	 *  - phonebook
@@ -337,8 +347,11 @@
 static int create_gril(struct ofono_modem *modem)
 {
 	struct ril_data *rd = ofono_modem_get_data(modem);
+	int slot_id = ofono_modem_get_integer(modem, "Slot");
 
-	rd->ril = g_ril_new(RILD_CMD_SOCKET, OFONO_RIL_VENDOR_AOSP);
+	ofono_info("Using %s as socket for slot %d.",
+					RILD_CMD_SOCKET[slot_id], slot_id);
+	rd->ril = g_ril_new(RILD_CMD_SOCKET[slot_id], OFONO_RIL_VENDOR_AOSP);
 
 	/* NOTE: Since AT modems open a tty, and then call
 	 * g_at_chat_new(), they're able to return -EIO if
@@ -352,12 +365,13 @@
 		ofono_error("g_ril_new() failed to create modem!");
 		return -EIO;
 	}
+	g_ril_set_slot(rd->ril, slot_id);
 
 	if (getenv("OFONO_RIL_TRACE"))
 		g_ril_set_trace(rd->ril, TRUE);
 
 	if (getenv("OFONO_RIL_HEX_TRACE"))
-		g_ril_set_debugf(rd->ril, ril_debug, "Device: ");
+		g_ril_set_debugf(rd->ril, ril_debug, GRIL_HEX_PREFIX[slot_id]);
 
 	g_ril_register(rd->ril, RIL_UNSOL_RIL_CONNECTED,
 			ril_connected, modem);

=== added file 'src/dns-client.c'
--- src/dns-client.c	1970-01-01 00:00:00 +0000
+++ src/dns-client.c	2015-07-02 17:01:42 +0000
@@ -0,0 +1,128 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
+ *  Copyright (C) 2015  Canonical Ltd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+#include <glib.h>
+#include "ofono.h"
+#include "dns-client.h"
+
+static GSList *g_drivers = NULL;
+
+ofono_dns_client_request_t __ofono_dns_client_submit_request(
+						const char *hostname,
+						const char *device,
+						const char **servers,
+						int timeout_ms,
+						ofono_dns_client_callback_t cb,
+						void *data)
+{
+	GSList *d;
+	ofono_dns_client_request_t token = NULL;
+
+	for (d = g_drivers; d != NULL; d = d->next) {
+		const struct ofono_dns_client_driver *driver = d->data;
+
+		if (driver->submit_request == NULL)
+			continue;
+
+		DBG("Calling dns client plugin '%s'", driver->name);
+
+		if ((token = driver->submit_request(hostname, device, servers,
+						timeout_ms, cb, data)) == NULL)
+			continue;
+
+		return token;
+	}
+
+	return token;
+}
+
+void __ofono_dns_client_cancel_request(ofono_dns_client_request_t request)
+{
+	GSList *d;
+
+	for (d = g_drivers; d != NULL; d = d->next) {
+		const struct ofono_dns_client_driver *driver = d->data;
+
+		if (driver->cancel_request == NULL)
+			continue;
+
+		/* Returns TRUE if this driver is the request owner */
+		if (driver->cancel_request(request))
+			break;
+	}
+}
+
+/*
+ * Returns a human-friendly error string corresponding to |status|.
+ * The strings that we return are intentionally consistent with shill error
+ * messages.
+ */
+const char *__ofono_dns_client_strerror(ofono_dns_client_status_t status)
+{
+	switch(status) {
+	case OFONO_DNS_CLIENT_SUCCESS:
+		return "The query was successful.";
+	case OFONO_DNS_CLIENT_ERROR_NO_DATA:
+		return "The query response contains no answers.";
+	case OFONO_DNS_CLIENT_ERROR_FORM_ERR:
+		return "The server says the query is bad.";
+	case OFONO_DNS_CLIENT_ERROR_SERVER_FAIL:
+		return "The server says it had a failure.";
+	case OFONO_DNS_CLIENT_ERROR_NOT_FOUND:
+		return "The queried-for domain was not found.";
+	case OFONO_DNS_CLIENT_ERROR_NOT_IMP:
+		return "The server doesn't implement operation.";
+	case OFONO_DNS_CLIENT_ERROR_REFUSED:
+		return "The server replied, refused the query.";
+	case OFONO_DNS_CLIENT_ERROR_BAD_QUERY:
+		return "Locally we could not format a query.";
+	case OFONO_DNS_CLIENT_ERROR_NET_REFUSED:
+		return "The network connection was refused.";
+	case OFONO_DNS_CLIENT_ERROR_TIMED_OUT:
+		return "The network connection was timed out.";
+	case OFONO_DNS_CLIENT_ERROR_UNKNOWN:
+	default:
+		return "DNS Resolver unknown internal error.";
+	}
+}
+
+int ofono_dns_client_driver_register(struct ofono_dns_client_driver *driver)
+{
+	DBG("driver: %p name: %s", driver, driver->name);
+
+	g_drivers = g_slist_prepend(g_drivers, driver);
+	return 0;
+}
+
+void ofono_dns_client_driver_unregister(
+			const struct ofono_dns_client_driver *driver)
+{
+	DBG("driver: %p name: %s", driver, driver->name);
+
+	g_drivers = g_slist_remove(g_drivers, driver);
+}

=== modified file 'src/gprs.c'
--- src/gprs.c	2015-05-20 16:32:09 +0000
+++ src/gprs.c	2015-07-02 17:01:42 +0000
@@ -35,6 +35,8 @@
 #include <net/route.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <resolv.h>
+#include <netdb.h>
 
 #include <glib.h>
 #include <gdbus.h>
@@ -46,6 +48,7 @@
 #include "idmap.h"
 #include "simutil.h"
 #include "util.h"
+#include "dns-client.h"
 
 #define GPRS_FLAG_ATTACHING 0x1
 #define GPRS_FLAG_RECHECK 0x2
@@ -58,6 +61,7 @@
 #define MAX_MESSAGE_CENTER_LENGTH 255
 #define MAX_CONTEXTS 256
 #define SUSPEND_TIMEOUT 8
+#define DNS_LOOKUP_TOUT_MS 15000
 
 struct ofono_gprs {
 	GSList *contexts;
@@ -97,6 +101,7 @@
 	char *gateway;
 	char **dns;
 	char *proxy;
+	uint16_t proxy_port;
 };
 
 struct ipv6_settings {
@@ -138,6 +143,7 @@
 	struct ofono_gprs_primary_context context;
 	struct ofono_gprs_context *context_driver;
 	struct ofono_gprs *gprs;
+	ofono_dns_client_request_t lookup_req;
 };
 
 static void gprs_netreg_update(struct ofono_gprs *gprs);
@@ -377,11 +383,11 @@
 	ofono_dbus_dict_append(&array, "Interface",
 				DBUS_TYPE_STRING, &settings->interface);
 
-	/* If we have a Proxy, no other settings are relevant */
 	if (settings->ipv4->proxy) {
 		ofono_dbus_dict_append(&array, "Proxy", DBUS_TYPE_STRING,
 					&settings->ipv4->proxy);
-		goto done;
+		ofono_dbus_dict_append(&array, "ProxyPort", DBUS_TYPE_UINT16,
+					&settings->ipv4->proxy_port);
 	}
 
 	if (settings->ipv4->static_ip == TRUE)
@@ -536,9 +542,183 @@
 				context_settings_append_ipv6);
 }
 
-static void pri_parse_proxy(struct pri_context *ctx, const char *proxy)
-{
-	char *scheme, *host, *port, *path;
+static void set_route(const struct context_settings *settings,
+					const char *ipstr, gboolean create)
+{
+	struct rtentry rt;
+	struct sockaddr_in addr;
+	int sk;
+	const char *debug_str = create ? "create" : "remove";
+
+	/* TODO Handle IPv6 case */
+
+	DBG("%s for %s", ipstr, debug_str);
+
+	if (settings->interface == NULL)
+		return;
+
+	sk = socket(PF_INET, SOCK_DGRAM, 0);
+	if (sk < 0)
+		return;
+
+	memset(&rt, 0, sizeof(rt));
+	rt.rt_dev = (char *) settings->interface;
+	rt.rt_flags = RTF_HOST;
+
+	if (create)
+		rt.rt_flags |= RTF_UP;
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sin_family = AF_INET;
+	addr.sin_addr.s_addr = inet_addr(ipstr);
+	if (addr.sin_addr.s_addr == INADDR_NONE) {
+		ofono_error("Cannot %s route for invalid IP %s",
+							debug_str, ipstr);
+		return;
+	}
+	memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sin_family = AF_INET;
+	addr.sin_addr.s_addr = INADDR_ANY;
+	memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
+	memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
+
+	if (ioctl(sk, create ? SIOCADDRT : SIOCDELRT, &rt) < 0)
+		ofono_error("Failed to %s proxy host route: %s (%d)",
+					debug_str, strerror(errno), errno);
+
+	close(sk);
+}
+
+static void pri_activate_finish(struct pri_context *ctx)
+{
+	struct ofono_gprs_context *gc = ctx->context_driver;
+	struct context_settings *settings = gc->settings;
+	DBusConnection *conn = ofono_dbus_get_connection();
+	dbus_bool_t value;
+
+	DBG("proxy %s port %u", ctx->proxy_host ? ctx->proxy_host : "NULL",
+							ctx->proxy_port);
+
+	if (ctx->proxy_host) {
+		settings->ipv4->proxy = g_strdup(ctx->proxy_host);
+		settings->ipv4->proxy_port = ctx->proxy_port;
+
+		if (ctx->type == OFONO_GPRS_CONTEXT_TYPE_MMS)
+			set_route(settings, ctx->proxy_host, TRUE);
+	}
+
+	ctx->active = TRUE;
+	__ofono_dbus_pending_reply(&ctx->pending,
+				dbus_message_new_method_return(ctx->pending));
+
+	if (gc->settings->interface != NULL)
+		pri_context_signal_settings(ctx, settings->ipv4 != NULL,
+							settings->ipv6 != NULL);
+
+	value = ctx->active;
+	ofono_dbus_signal_property_changed(conn, ctx->path,
+					OFONO_CONNECTION_CONTEXT_INTERFACE,
+					"Active", DBUS_TYPE_BOOLEAN, &value);
+}
+
+static void clean_dns_routes(struct pri_context *ctx)
+{
+	struct context_settings *settings = ctx->context_driver->settings;
+	int i;
+
+	for (i = 0; settings->ipv4->dns[i] != NULL; ++i)
+		set_route(settings, settings->ipv4->dns[i], FALSE);
+}
+
+static void lookup_address_cb(void *data, ofono_dns_client_status_t status,
+						struct sockaddr *ip_addr)
+{
+	struct pri_context *ctx = data;
+	char str[INET_ADDRSTRLEN];
+
+	if (status == OFONO_DNS_CLIENT_SUCCESS) {
+		void *addr;
+
+		if (ip_addr->sa_family == AF_INET) {
+			struct sockaddr_in *ip4 = (void *) ip_addr;
+			addr = &ip4->sin_addr;
+		} else {
+			/* Assume ipv6 */
+			struct sockaddr_in6 *ip6 = (void *) ip_addr;
+			addr = &ip6->sin6_addr;
+		}
+
+		if (inet_ntop(ip_addr->sa_family, addr, str, sizeof(str)))
+			ctx->proxy_host = g_strdup(str);
+		else
+			ofono_error("%s: Cannot convert type %d to address",
+						__func__, ip_addr->sa_family);
+	} else {
+		ofono_error("DNS error %s",
+					__ofono_dns_client_strerror(status));
+	}
+
+	ctx->lookup_req = NULL;
+
+	clean_dns_routes(ctx);
+	pri_activate_finish(ctx);
+}
+
+static void lookup_address(struct pri_context *ctx, const char *proxy)
+{
+	struct context_settings *settings = ctx->context_driver->settings;
+
+	DBG("hostname is %s", proxy);
+
+	ctx->lookup_req = __ofono_dns_client_submit_request(
+					proxy, settings->interface,
+					(const char **) settings->ipv4->dns,
+					DNS_LOOKUP_TOUT_MS,
+					lookup_address_cb, ctx);
+	if (ctx->lookup_req == NULL)
+		clean_dns_routes(ctx);
+}
+
+static void get_proxy_ip(struct pri_context *ctx, const char *host)
+{
+	struct context_settings *settings = ctx->context_driver->settings;
+	struct in_addr addr;
+	int i;
+
+	if (inet_pton(AF_INET, host, &addr) == 1) {
+		ctx->proxy_host = g_strdup(host);
+		return;
+	}
+
+	/* Not an IP -> use DNS if possible */
+
+	if (settings->ipv4 == NULL || settings->ipv4->dns == NULL ||
+			settings->ipv4->dns[0] == NULL) {
+		ofono_error("No DNS to find IP for MMS proxy/MMSC %s", host);
+		return;
+	}
+
+	for (i = 0; settings->ipv4->dns[i] != NULL; ++i)
+		set_route(settings, settings->ipv4->dns[i], TRUE);
+
+	lookup_address(ctx, host);
+}
+
+static void pri_parse_proxy(struct pri_context *ctx)
+{
+	char *proxy, *scheme, *host, *port, *path;
+
+	g_free(ctx->proxy_host);
+	ctx->proxy_host = NULL;
+
+	if (ctx->message_proxy[0] != '\0')
+		proxy = ctx->message_proxy;
+	else if (ctx->message_center[0] != '\0')
+		proxy = ctx->message_center;
+	else
+		return;
 
 	scheme = g_strdup(proxy);
 	if (scheme == NULL)
@@ -577,8 +757,7 @@
 		}
 	}
 
-	g_free(ctx->proxy_host);
-	ctx->proxy_host = g_strdup(host);
+	get_proxy_ip(ctx, host);
 
 	g_free(scheme);
 }
@@ -662,44 +841,6 @@
 	close(sk);
 }
 
-static void pri_setproxy(const char *interface, const char *proxy)
-{
-	struct rtentry rt;
-	struct sockaddr_in addr;
-	int sk;
-
-	if (interface == NULL)
-		return;
-
-	sk = socket(PF_INET, SOCK_DGRAM, 0);
-	if (sk < 0)
-		return;
-
-	memset(&rt, 0, sizeof(rt));
-	rt.rt_flags = RTF_UP | RTF_HOST;
-	rt.rt_dev = (char *) interface;
-
-	memset(&addr, 0, sizeof(addr));
-	addr.sin_family = AF_INET;
-	addr.sin_addr.s_addr = inet_addr(proxy);
-	memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
-
-	memset(&addr, 0, sizeof(addr));
-	addr.sin_family = AF_INET;
-	addr.sin_addr.s_addr = INADDR_ANY;
-	memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
-
-	memset(&addr, 0, sizeof(addr));
-	addr.sin_family = AF_INET;
-	addr.sin_addr.s_addr = INADDR_ANY;
-	memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
-
-	if (ioctl(sk, SIOCADDRT, &rt) < 0)
-		ofono_error("Failed to add proxy host route");
-
-	close(sk);
-}
-
 static void pri_reset_context_settings(struct pri_context *ctx)
 {
 	struct context_settings *settings;
@@ -736,24 +877,6 @@
 	g_free(interface);
 }
 
-static void pri_update_mms_context_settings(struct pri_context *ctx)
-{
-	struct ofono_gprs_context *gc = ctx->context_driver;
-	struct context_settings *settings = gc->settings;
-
-	if (ctx->message_proxy)
-		settings->ipv4->proxy = g_strdup(ctx->message_proxy);
-
-	pri_parse_proxy(ctx, ctx->message_proxy);
-
-	DBG("proxy %s port %u", ctx->proxy_host, ctx->proxy_port);
-
-	pri_set_ipv4_addr(settings->interface, settings->ipv4->ip);
-
-	if (ctx->proxy_host)
-		pri_setproxy(settings->interface, ctx->proxy_host);
-}
-
 static void append_context_properties(struct pri_context *ctx,
 					DBusMessageIter *dict)
 {
@@ -835,8 +958,6 @@
 {
 	struct pri_context *ctx = data;
 	struct ofono_gprs_context *gc = ctx->context_driver;
-	DBusConnection *conn = ofono_dbus_get_connection();
-	dbus_bool_t value;
 
 	DBG("%p", ctx);
 
@@ -850,25 +971,23 @@
 		return;
 	}
 
-	ctx->active = TRUE;
-	__ofono_dbus_pending_reply(&ctx->pending,
-				dbus_message_new_method_return(ctx->pending));
-
 	if (gc->settings->interface != NULL) {
 		pri_ifupdown(gc->settings->interface, TRUE);
 
-		if (ctx->type == OFONO_GPRS_CONTEXT_TYPE_MMS &&
-				gc->settings->ipv4)
-			pri_update_mms_context_settings(ctx);
-
-		pri_context_signal_settings(ctx, gc->settings->ipv4 != NULL,
-						gc->settings->ipv6 != NULL);
+		if (gc->settings->ipv4) {
+			if (ctx->type == OFONO_GPRS_CONTEXT_TYPE_MMS)
+				pri_set_ipv4_addr(gc->settings->interface,
+							gc->settings->ipv4->ip);
+
+			pri_parse_proxy(ctx);
+
+			/* Not answer yet if waiting for DNS lookup */
+			if (ctx->lookup_req != NULL)
+				return;
+		}
 	}
 
-	value = ctx->active;
-	ofono_dbus_signal_property_changed(conn, ctx->path,
-					OFONO_CONNECTION_CONTEXT_INTERFACE,
-					"Active", DBUS_TYPE_BOOLEAN, &value);
+	pri_activate_finish(ctx);
 }
 
 static void pri_deactivate_callback(const struct ofono_error *error, void *data)
@@ -897,15 +1016,11 @@
 					"Active", DBUS_TYPE_BOOLEAN, &value);
 }
 
-static DBusMessage *pri_set_preferred(struct pri_context *ctx,
-					DBusConnection *conn,
-					DBusMessage *msg, gboolean preferred)
+static void set_preferred(struct pri_context *ctx, DBusConnection *conn,
+							gboolean preferred)
 {
 	GKeyFile *settings = ctx->gprs->settings;
 
-	if (ctx->preferred == preferred)
-		return dbus_message_new_method_return(msg);
-
 	ctx->preferred = preferred;
 
 	if (settings) {
@@ -914,12 +1029,22 @@
 		storage_sync(ctx->gprs->imsi, SETTINGS_STORE, settings);
 	}
 
-	g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
-
 	ofono_dbus_signal_property_changed(conn, ctx->path,
 					OFONO_CONNECTION_CONTEXT_INTERFACE,
 					"Preferred", DBUS_TYPE_BOOLEAN,
 					&preferred);
+}
+
+static DBusMessage *pri_set_preferred(struct pri_context *ctx,
+					DBusConnection *conn,
+					DBusMessage *msg, gboolean preferred)
+{
+	if (ctx->preferred == preferred)
+		return dbus_message_new_method_return(msg);
+
+	g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
+
+	set_preferred(ctx, conn, preferred);
 
 	return NULL;
 }
@@ -3186,20 +3311,48 @@
 static struct pri_context *gprs_context_for_ia(struct ofono_gprs *gprs)
 {
 	GSList *l;
-
-	for (l = gprs->contexts; l; l = l->next) {
-		struct pri_context *ctx = l->data;
-
-		if (ctx->type == OFONO_GPRS_CONTEXT_TYPE_IA)
-			return ctx;
-	}
-
-	for (l = gprs->contexts; l; l = l->next) {
-		struct pri_context *ctx = l->data;
-
-		if (ctx->type == OFONO_GPRS_CONTEXT_TYPE_INTERNET)
-			return ctx;
-	}
+	struct pri_context *ctx_ia = NULL;
+	struct pri_context *ctx_inet_pref = NULL;
+	struct pri_context *ctx_inet = NULL;
+	struct pri_context *ctx_other_pref = NULL;
+
+	for (l = gprs->contexts; l; l = l->next) {
+		struct pri_context *ctx = l->data;
+
+		if (ctx->type == OFONO_GPRS_CONTEXT_TYPE_IA) {
+			if (ctx->preferred)
+				return ctx;
+
+			if (ctx_ia == NULL)
+				ctx_ia = ctx;
+		} else if (ctx->type == OFONO_GPRS_CONTEXT_TYPE_INTERNET) {
+
+			if (ctx->preferred && ctx_inet_pref == NULL)
+				ctx_inet_pref = ctx;
+			else if (ctx_inet == NULL)
+				ctx_inet = ctx;
+
+		} else if (ctx->preferred && ctx_other_pref == NULL) {
+			ctx_other_pref = ctx;
+		}
+	}
+
+	if (ctx_ia != NULL) {
+		set_preferred(ctx_ia, ofono_dbus_get_connection(), TRUE);
+		return ctx_ia;
+	}
+
+	if (ctx_inet_pref != NULL)
+		return ctx_inet_pref;
+
+	if (ctx_inet != NULL)
+		return ctx_inet;
+
+	if (ctx_other_pref != NULL)
+		return ctx_other_pref;
+
+	if (gprs->contexts == NULL)
+		return NULL;
 
 	return gprs->contexts->data;
 }
@@ -3213,11 +3366,16 @@
 static void set_ia_apn(struct ofono_gprs *gprs)
 {
 	struct pri_context *ctx = gprs_context_for_ia(gprs);
-	struct ofono_gprs_primary_context *ofono_ctx = &ctx->context;
+	struct ofono_gprs_primary_context *ofono_ctx;
 	char mccmnc[OFONO_MAX_MCC_LENGTH + OFONO_MAX_MNC_LENGTH + 1];
 	const char *mcc = ofono_sim_get_mcc(gprs->sim);
 	const char *mnc = ofono_sim_get_mnc(gprs->sim);
 
+	if (ctx == NULL)
+		return;
+
+	ofono_ctx = &ctx->context;
+
 	strcpy(mccmnc, mcc);
 	strcpy(mccmnc + strlen(mcc), mnc);
 

=== modified file 'src/radio-settings.c'
--- src/radio-settings.c	2014-07-24 08:31:18 +0000
+++ src/radio-settings.c	2015-07-02 17:01:42 +0000
@@ -338,7 +338,7 @@
 	radio_set_band(rs);
 }
 
-static void radio_set_rat_mode(struct ofono_radio_settings *rs,
+void ofono_radio_settings_set_rat_mode(struct ofono_radio_settings *rs,
 				enum ofono_radio_access_mode mode)
 {
 	DBusConnection *conn = ofono_dbus_get_connection();
@@ -378,7 +378,7 @@
 	reply = dbus_message_new_method_return(rs->pending);
 	__ofono_dbus_pending_reply(&rs->pending, reply);
 
-	radio_set_rat_mode(rs, rs->pending_mode);
+	ofono_radio_settings_set_rat_mode(rs, rs->pending_mode);
 }
 
 static void radio_send_properties_reply(struct ofono_radio_settings *rs)
@@ -513,7 +513,7 @@
 		return;
 	}
 
-	radio_set_rat_mode(rs, mode);
+	ofono_radio_settings_set_rat_mode(rs, mode);
 	radio_query_band(rs);
 }
 

=== modified file 'test/list-contexts'
--- test/list-contexts	2014-02-26 09:12:18 +0000
+++ test/list-contexts	2015-07-02 17:01:42 +0000
@@ -31,7 +31,7 @@
 					if i in ["DomainNameServers"]:
 						for n in properties[key][i]:
 							val += n + ","
-					elif i in ["PrefixLength"]:
+					elif i in ["PrefixLength", "ProxyPort"]:
 						p = int(properties[key][i])
 						val += str(p)
 					else:

=== modified file 'test/list-modems'
--- test/list-modems	2015-05-20 16:32:09 +0000
+++ test/list-modems	2015-07-02 17:01:42 +0000
@@ -13,10 +13,11 @@
 	parser.add_argument("-p",
 			"--private",
 			dest="priv",
-			help="""Specifies that properties considered private
-			should be output as clear-text vs. obfuscated""",
-			action="store_false",
-			default="true"
+			help="""Specifies that properties considered
+			private	should be output obfuscated vs.
+			cleartext (default).""",
+			action="store_true",
+			default=False
 			)
 
 	return parser.parse_args()

=== modified file 'test/rilmodem/sim/simtestutil.py'
--- test/rilmodem/sim/simtestutil.py	2014-12-15 19:11:43 +0000
+++ test/rilmodem/sim/simtestutil.py	2015-07-02 17:01:42 +0000
@@ -176,7 +176,7 @@
 							path),
 							'org.ofono.SimManager')
 	def if_supports_sim_offline(self):
-		if self.product != "krillin":
+		if self.product != "krillin" and self.product != "arale":
 			return True
 		else:
 			return False
@@ -225,7 +225,7 @@
 			else:
                                 check_features = no_sim_online_features[:]
 		else:
-			if self.product == "krillin":
+			if self.product == "krillin" or self.product == "arale":
 				check_features = []
 			else:
 				if test_sims:
@@ -264,7 +264,7 @@
 		else:
 
 			# krillin no diff between sim/no-SIM when offline
-			if self.product == "krillin":
+			if self.product == "krillin" or self.product == "arale":
 				check_ifaces = no_sim_offline_ifaces[:]
 				check_ifaces.append("org.ofono.NetworkTime")
 			else:
@@ -298,7 +298,7 @@
 		#
 		# https://bugs.launchpad.net/ubuntu/+source/ofono/+bug/1396317
 
-		if self.product == "krillin":
+		if self.product == "krillin" or self.product == "arale":
 			self.assertTrue(properties["Muted"] == 0)
 		else:
 			self.assertTrue(properties["Muted"] == 1)

=== modified file 'test/rilmodem/sim/test-no-sims-offline'
--- test/rilmodem/sim/test-no-sims-offline	2014-12-15 19:11:43 +0000
+++ test/rilmodem/sim/test-no-sims-offline	2015-07-02 17:01:42 +0000
@@ -67,7 +67,7 @@
 		self.validate_modem_properties(path, False, False)
 
 		# krillin doesn't expose SimManager when offline
-		if (self.product != "krillin"):
+		if (self.product != "krillin" and self.product != "arale"):
 			self.assertTrue(self.check_no_sim_present(path))
 
 		self.validate_emergency_numbers(path)

=== modified file 'test/rilmodem/sim/test-sims-offline'
--- test/rilmodem/sim/test-sims-offline	2014-12-12 15:51:15 +0000
+++ test/rilmodem/sim/test-sims-offline	2015-07-02 17:01:42 +0000
@@ -89,7 +89,7 @@
 		self.validate_modem_properties(path, False, True)
 
 		# krillin: no SIM access when modem offline
-		if (self.product != "krillin"):
+		if (self.product != "krillin" and self.product != "arale"):
 			self.validate_sim_properties(path, self.args.mcc,
 							self.args.mnc,
 							self.args.subscriber)