Merge lp:~phablet-team/ofono/pro5-support-and-more into lp:~phablet-team/ofono/ubuntu

[Alfonso Sanchez-Beato]

[ Tony Espy ]
* unit: new rilmodem tests for sms and call barring
* plugins: address upower plugin upstream comments
* unit: fix test-grilreply set_facility_lock test
* style fixes for wakelock support

[ Ratchanan Srirattanamet ]
* qcommsimmodem: fix setting 3G pref when one of the slots is empty

[ Alfonso Sanchez-Beato ]
* ril: set properly gril vendor
* support for system settings
* unit: make unit tests parallelizable

[ Vicamo Yang ]
* ril, gril: support for pro 5
* gril, rilmodem: set RIL version from CONNECTED event
* unit: fix warning

[ Tony Espy ]
* unit: new rilmodem tests for sms and call barring
* plugins: address upower plugin upstream comments
* unit: fix test-grilreply set_facility_lock test
* style fixes for wakelock support

[ Ratchanan Srirattanamet ]
* qcommsimmodem: fix setting 3G pref when one of the slots is empty

[ Alfonso Sanchez-Beato ]
* ril: set properly gril vendor
* support for system settings
* unit: make unit tests parallelizable

[ Vicamo Yang ]
* ril, gril: support for pro 5
* gril, rilmodem: set RIL version from CONNECTED event
* unit: fix warning

[lp:~phablet-team/ofono/pro5-support-and-more]

6913. By Alfonso Sanchez-Beato on 2016-03-14

Add libsystemd dependency

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

Basic tests performed on krillin, rc-proposed/bq-aquaris.en #279, all looked good.

[Tony Espy (awe)]

Looks good to me...

review: Approve

=== modified file '.gitignore'
--- .gitignore	2015-07-31 12:46:34 +0000
+++ .gitignore	2016-03-14 09:03:03 +0000
@@ -52,6 +52,9 @@
 unit/test-mtkreply
 unit/test-mtkrequest
 unit/test-mtkunsol
+unit/test-rilmodem-cs
+unit/test-rilmodem-sms
+unit/test-rilmodem-cb
 unit/test-*.log
 unit/test-*.trs
 
 
=== modified file 'Makefile.am'
--- Makefile.am	2016-01-15 16:03:09 +0000
+++ Makefile.am	2016-03-14 09:03:03 +0000
@@ -23,7 +23,8 @@
 			include/cdma-provision.h include/handsfree.h \
 			include/handsfree-audio.h include/siri.h \
 			include/sim-mnclength.h include/spn-table.h \
-			include/dns-client.h include/wakelock.h
+			include/dns-client.h include/wakelock.h \
+			include/system-settings.h
 
 nodist_pkginclude_HEADERS = include/version.h
 
@@ -621,6 +622,14 @@
 builtin_sources += plugins/android-wakelock.c
 endif
 
+if ACCOUNTSSETTINGS
+builtin_modules += accounts_settings
+builtin_sources += plugins/accounts-settings.c
+
+builtin_cflags += @SYSTEMD_CFLAGS@
+builtin_libadd += @SYSTEMD_LIBS@
+endif
+
 sbin_PROGRAMS = src/ofonod
 
 src_ofonod_SOURCES = $(builtin_sources) src/ofono.ver \
@@ -650,7 +659,8 @@
 			src/handsfree-audio.c src/bluetooth.h \
 			src/hfp.h src/siri.c \
 			src/sim-mnclength.c src/spn-table.c \
-			src/dns-client.c src/wakelock.c
+			src/dns-client.c src/wakelock.c \
+			src/system-settings.c
 
 src_ofonod_LDADD = gdbus/libgdbus-internal.la $(builtin_libadd) \
 			@GLIB_LIBS@ @DBUS_LIBS@ -ldl
@@ -817,7 +827,9 @@
 				unit/test-mtkrequest \
 				unit/test-mtkreply \
 				unit/test-mtkunsol \
-				unit/test-rilmodem-cs
+				unit/test-rilmodem-cs \
+				unit/test-rilmodem-sms \
+				unit/test-rilmodem-cb
 
 noinst_PROGRAMS = $(unit_tests) \
 			unit/test-sms-root unit/test-mux unit/test-caif
@@ -913,14 +925,33 @@
 unit_test_mnclength_LDADD = @GLIB_LIBS@ -ldl
 unit_objects += $(unit_test_mnclength_OBJECTS)
 
-unit_test_rilmodem_cs_SOURCES = unit/test-rilmodem-cs.c $(gril_sources) \
-			src/log.c src/common.c src/util.c \
-			drivers/rilmodem/call-settings.c \
-			src/simutil.c gatchat/ringbuffer.c
+test_rilmodem_sources = $(gril_sources) src/log.c src/common.c src/util.c \
+				gatchat/ringbuffer.h gatchat/ringbuffer.c \
+				unit/rilmodem-test-server.h \
+				unit/rilmodem-test-server.c \
+				src/simutil.c
+
+unit_test_rilmodem_cs_SOURCES = $(test_rilmodem_sources) \
+					unit/test-rilmodem-cs.c \
+					drivers/rilmodem/call-settings.c
 unit_test_rilmodem_cs_LDADD = gdbus/libgdbus-internal.la $(builtin_libadd) \
-			@GLIB_LIBS@ @DBUS_LIBS@ -ldl
+					@GLIB_LIBS@ @DBUS_LIBS@ -ldl
 unit_objects += $(unit_test_rilmodem_cs_OBJECTS)
 
+unit_test_rilmodem_sms_SOURCES = $(test_rilmodem_sources) \
+					unit/test-rilmodem-sms.c \
+					drivers/rilmodem/sms.c
+unit_test_rilmodem_sms_LDADD = gdbus/libgdbus-internal.la $(builtin_libadd) \
+					@GLIB_LIBS@ @DBUS_LIBS@ -ldl
+unit_objects += $(unit_test_rilmodem_sms_OBJECTS)
+
+unit_test_rilmodem_cb_SOURCES = $(test_rilmodem_sources) \
+					unit/test-rilmodem-cb.c \
+					drivers/rilmodem/call-barring.c
+unit_test_rilmodem_cb_LDADD = gdbus/libgdbus-internal.la $(builtin_libadd) \
+					@GLIB_LIBS@ @DBUS_LIBS@ -ldl
+unit_objects += $(unit_test_rilmodem_cb_OBJECTS)
+
 TESTS = $(unit_tests)
 
 if TOOLS
 
=== modified file 'configure.ac'
--- configure.ac	2016-01-15 16:03:09 +0000
+++ configure.ac	2016-03-14 09:03:03 +0000
@@ -200,6 +200,17 @@
 AC_SUBST(CARES_LIBS)
 AM_CONDITIONAL(CARES, test "${enable_cares}" != "no")
 
+AC_ARG_ENABLE(accounts-settings, AC_HELP_STRING([--disable-accounts-settings],
+			[disable using accounts service for system settings]),
+					[enable_accounts_settings=${enableval}])
+if (test "${enable_accounts_settings=$}" != "no"); then
+	PKG_CHECK_MODULES(SYSTEMD, libsystemd, dummy=yes,
+					AC_MSG_ERROR(libsystemd is required))
+fi
+AC_SUBST(SYSTEMD_CFLAGS)
+AC_SUBST(SYSTEMD_LIBS)
+AM_CONDITIONAL(ACCOUNTSSETTINGS, test "${enable_accounts_settings=$}" != "no")
+
 AC_ARG_ENABLE(nettime, AC_HELP_STRING([--disable-nettime],
                                 [disable Nettime plugin]),
                                         [enable_nettime=${enableval}])
 
=== modified file 'debian/changelog'
--- debian/changelog	2016-01-15 17:37:10 +0000
+++ debian/changelog	2016-03-14 09:03:03 +0000
@@ -1,3 +1,26 @@
+ofono (1.17.bzr6912+16.04.20160314.1-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Tony Espy ]
+  * unit: new rilmodem tests for sms and call barring
+  * plugins: address upower plugin upstream comments
+  * unit: fix test-grilreply set_facility_lock test
+  * style fixes for wakelock support
+
+  [ Ratchanan Srirattanamet ]
+  * qcommsimmodem: fix setting 3G pref when one of the slots is empty
+
+  [ Alfonso Sanchez-Beato ]
+  * ril: set properly gril vendor
+  * support for system settings
+  * unit: make tests parallelizable
+
+  [ Vicamo Yang ]
+  * ril, gril: support for pro 5
+  * gril, rilmodem: set RIL version from CONNECTED event
+  * unit: fix warning
+
+ -- Alfonso Sanchez-Beato (email Canonical) <[e-mail]>  Mon, 14 Mar 2016 09:07:47 +0100
+
 ofono (1.17.bzr6910+16.04.20160115.3-0ubuntu1) xenial; urgency=medium
 
   [ Simon Fels ]
 
=== modified file 'debian/control'
--- debian/control	2015-07-01 07:00:40 +0000
+++ debian/control	2016-03-14 09:03:03 +0000
@@ -14,7 +14,8 @@
                udev,
                libbluetooth-dev (>= 4.30),
                mobile-broadband-provider-info,
-               libc-ares-dev
+               libc-ares-dev,
+               libsystemd-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/qcommsimmodem/radio-settings.c'
--- drivers/qcommsimmodem/radio-settings.c	2015-07-31 13:44:26 +0000
+++ drivers/qcommsimmodem/radio-settings.c	2016-03-14 09:03:03 +0000
@@ -31,10 +31,12 @@
 #include <errno.h>
 
 #include <glib.h>
+#include <ofono.h>
 
 #include <ofono/log.h>
 #include <ofono/modem.h>
 #include <ofono/radio-settings.h>
+#include <ofono/sim.h>
 
 #include "gril.h"
 #include "grilrequest.h"
@@ -58,7 +60,6 @@
 };
 
 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)
 {
@@ -76,6 +77,24 @@
 	}
 }
 
+static void qcom_msim_do_set_rat_mode(struct ofono_radio_settings *rs, int pref,
+							struct cb_data *cbd)
+{
+	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+	struct parcel rilp;
+	ofono_radio_settings_rat_mode_set_cb_t cb;
+
+	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__);
+		cb = cbd->cb;
+		CALLBACK_WITH_FAILURE(cb, cbd->data);
+		g_free(cbd);
+	}
+}
+
 static void qcom_msim_set_2g_rat_cb(struct ril_msg *message,
 							gpointer user_data)
 {
@@ -84,7 +103,6 @@
 	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;
 
@@ -104,23 +122,8 @@
 	}
 
 	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);
-			}
-		}
+		if (pps->cbd != NULL)
+			qcom_msim_do_set_rat_mode(pps->rs, pps->pref, pps->cbd);
 
 		g_free(pps);
 	}
@@ -131,10 +134,10 @@
 			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;
+	struct qcom_msim_pending_pref_setting *pps = NULL;
 
 	switch (mode) {
 	case OFONO_RADIO_ACCESS_MODE_ANY:
@@ -151,24 +154,43 @@
 		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);
+	if (pref != PREF_NET_TYPE_GSM_ONLY) {
 		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;
+			struct ofono_atom *sim_atom;
+			struct ofono_sim *sim;
 
 			if (multisim_rs[i] == rs || multisim_rs[i] == NULL)
 				continue;
 
 			temp_rd = ofono_radio_settings_get_data(multisim_rs[i]);
+			sim_atom = __ofono_modem_find_atom(temp_rd->modem,
+							OFONO_ATOM_TYPE_SIM);
+			if (sim_atom == NULL) {
+				if (pps != NULL)
+					pps->cbd = NULL;
+				g_free(cbd);
+				CALLBACK_WITH_FAILURE(cb, data);
+				break;
+			}
+
+			sim = __ofono_atom_get_data(sim_atom);
+			if (ofono_sim_get_state(sim) ==
+						OFONO_SIM_STATE_NOT_PRESENT)
+				continue;
+
+			if (pps == NULL) {
+				pps = g_try_new0(
+					struct qcom_msim_pending_pref_setting,
+									1);
+				pps->rs = rs;
+				pps->pref = pref;
+				pps->cbd = cbd;
+				pps->pending_gsm_pref_remaining = 0;
+			}
+
 			set_2g_rat_data =
 				g_try_new0(struct qcom_msim_set_2g_rat, 1);
 			set_2g_rat_data->pps = pps;
@@ -192,20 +214,15 @@
 				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);
-		}
-	}
+	}
+
+	if (pps && pps->pending_gsm_pref_remaining == 0) {
+		g_free(pps);
+		pps = NULL;
+	}
+
+	if (pps == NULL)
+		qcom_msim_do_set_rat_mode(rs, pref, cbd);
 }
 
 static int qcom_msim_radio_settings_probe(struct ofono_radio_settings *rs,
@@ -229,7 +246,6 @@
 
 	slot_id = ofono_modem_get_integer(rsd->modem, "Slot");
 	multisim_rs[slot_id] = rs;
-	multisim_num_slots += 1;
 
 	return 0;
 }
@@ -240,7 +256,6 @@
 	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);
 
 
=== modified file 'drivers/rilmodem/call-barring.c'
--- drivers/rilmodem/call-barring.c	2014-04-21 07:56:17 +0000
+++ drivers/rilmodem/call-barring.c	2016-03-14 09:03:03 +0000
@@ -105,8 +105,8 @@
 		goto error;
 	}
 
-	/* Just for printing return value */
-	g_ril_reply_parse_set_facility_lock(bd->ril, message);
+	if (g_ril_reply_parse_set_facility_lock(bd->ril, message) < 0)
+		goto error;
 
 	CALLBACK_WITH_SUCCESS(cb, cbd->data);
 	return;
 
=== modified file 'drivers/rilmodem/sim.c'
--- drivers/rilmodem/sim.c	2015-10-07 07:14:11 +0000
+++ drivers/rilmodem/sim.c	2016-03-14 09:03:03 +0000
@@ -733,6 +733,12 @@
 	struct reply_sim_status *status;
 	guint search_index;
 
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("%s: RIL error %s", __func__,
+				ril_error_to_string(message->error));
+		return;
+	}
+
 	status = g_ril_reply_parse_sim_status(sd->ril, message);
 	if (status == NULL) {
 		ofono_error("%s: Cannot parse SIM status reply", __func__);
 
=== modified file 'drivers/rilmodem/sms.c'
--- drivers/rilmodem/sms.c	2014-04-15 23:42:56 +0000
+++ drivers/rilmodem/sms.c	2016-03-14 09:03:03 +0000
@@ -127,19 +127,17 @@
 static void ril_submit_sms_cb(struct ril_msg *message, gpointer user_data)
 {
 	struct cb_data *cbd = user_data;
-	struct ofono_error error;
 	ofono_sms_submit_cb_t cb = cbd->cb;
 	struct sms_data *sd = cbd->user;
-	int mr = 0;
+	int mr;
 
-	if (message->error == RIL_E_SUCCESS) {
-		decode_ril_error(&error, "OK");
-		mr = g_ril_reply_parse_sms_response(sd->ril, message);
-	} else {
-		decode_ril_error(&error, "FAIL");
+	if (message->error != RIL_E_SUCCESS) {
+		CALLBACK_WITH_FAILURE(cb, 0, cbd->data);
+		return;
 	}
 
-	cb(&error, mr, cbd->data);
+	mr = g_ril_reply_parse_sms_response(sd->ril, message);
+	CALLBACK_WITH_SUCCESS(cb, mr, cbd->data);
 }
 
 static void ril_cmgs(struct ofono_sms *sms, const unsigned char *pdu,
 
=== modified file 'gril/gril.c'
--- gril/gril.c	2015-11-10 09:17:36 +0000
+++ gril/gril.c	2016-03-14 09:03:03 +0000
@@ -104,6 +104,7 @@
 	int slot;
 	GRilMsgIdToStrFunc req_to_string;
 	GRilMsgIdToStrFunc unsol_to_string;
+	int version;
 };
 
 struct _GRil {
@@ -1066,6 +1067,7 @@
 	ril->ref_count = 1;
 
 	ril->parent->vendor = vendor;
+	ril->parent->version = RIL_VERSION_UNSPECIFIED;
 
 	return ril;
 }
@@ -1207,6 +1209,24 @@
 	return ril->parent->slot;
 }
 
+gboolean g_ril_set_version(GRil *ril, int version)
+{
+	if (ril == NULL || ril->parent == NULL ||
+			ril->parent->version != RIL_VERSION_UNSPECIFIED)
+		return FALSE;
+
+	ril->parent->version = version;
+	return TRUE;
+}
+
+int g_ril_get_version(GRil *ril)
+{
+	if (ril == NULL)
+		return RIL_VERSION_UNSPECIFIED;
+
+	return ril->parent->version;
+}
+
 gboolean g_ril_set_debugf(GRil *ril,
 			GRilDebugFunc func, gpointer user_data)
 {
 
=== modified file 'gril/gril.h'
--- gril/gril.h	2014-07-31 06:45:32 +0000
+++ gril/gril.h	2016-03-14 09:03:03 +0000
@@ -129,6 +129,9 @@
 int g_ril_get_slot(GRil *ril);
 gboolean g_ril_set_slot(GRil *ril, int slot);
 
+int g_ril_get_version(GRil *ril);
+gboolean g_ril_set_version(GRil *ril, int version);
+
 /*!
  * If the function is not NULL, then on every read/write from the GIOChannel
  * provided to GRil the logging function will be called with the
 
=== modified file 'gril/grilreply.c'
--- gril/grilreply.c	2015-10-23 07:09:51 +0000
+++ gril/grilreply.c	2016-03-14 09:03:03 +0000
@@ -1258,8 +1258,10 @@
 	g_ril_init_parcel(message, &rilp);
 
 	/* mako reply has no payload for call barring */
-	if (parcel_data_avail(&rilp) == 0)
-		goto end;
+	if (parcel_data_avail(&rilp) == 0) {
+		retries = 0;
+		goto done;
+	}
 
 	numint = parcel_r_int32(&rilp);
 	if (numint != 1) {
@@ -1271,13 +1273,19 @@
 
 	if (rilp.malformed) {
 		ofono_error("%s: malformed parcel", __func__);
+		retries = -1;
 		goto end;
 	}
 
-end:
+done:
 	g_ril_append_print_buf(gril, "{%d}", retries);
 	g_ril_print_response(gril, message);
 
+	/* -1 indicates unknown; reset to 0 so as to not trigger failure */
+	if (retries == -1)
+		retries = 0;
+
+end:
 	return retries;
 }
 
 
=== modified file 'gril/grilunsol.c'
--- gril/grilunsol.c	2015-09-29 08:47:19 +0000
+++ gril/grilunsol.c	2016-03-14 09:03:03 +0000
@@ -48,6 +48,30 @@
  */
 #define MIN_NITZ_SIZE 17
 
+int g_ril_unsol_parse_connected(GRil *gril, const struct ril_msg *message)
+{
+	struct parcel rilp;
+	int size;
+	int version;
+
+	DBG("");
+
+	g_ril_init_parcel(message, &rilp);
+
+	size = parcel_r_int32(&rilp);
+	version = parcel_r_int32(&rilp);
+
+	if (rilp.malformed) {
+		ofono_error("%s: malformed parcel", __func__);
+		version = RIL_VERSION_UNSPECIFIED;
+	}
+
+	g_ril_append_print_buf(gril, "{size:%d, [%d, ...]}", size, version);
+	g_ril_print_unsol(gril, message);
+
+	return version;
+}
+
 static gint data_call_compare(gconstpointer a, gconstpointer b)
 {
 	const struct ril_data_call *ca = a;
 
=== modified file 'gril/grilunsol.h'
--- gril/grilunsol.h	2014-08-11 12:41:11 +0000
+++ gril/grilunsol.h	2016-03-14 09:03:03 +0000
@@ -64,6 +64,8 @@
 	char *message;
 };
 
+int g_ril_unsol_parse_connected(GRil *gril, const struct ril_msg *message);
+
 void g_ril_unsol_free_data_call_list(struct ril_data_call_list *data_call_list);
 
 
 
=== modified file 'gril/ril_constants.h'
--- gril/ril_constants.h	2015-02-18 13:54:39 +0000
+++ gril/ril_constants.h	2016-03-14 09:03:03 +0000
@@ -23,7 +23,8 @@
 
 #ifndef __RIL_CONSTANTS_H
 #define __RIL_CONSTANTS_H 1
-#define RIL_VERSION 7
+
+#define RIL_VERSION_UNSPECIFIED 0
 
 /* Error Codes */
 #define RIL_E_SUCCESS 0
 
=== modified file 'include/log.h'
--- include/log.h	2011-10-10 20:39:42 +0000
+++ include/log.h	2016-03-14 09:03:03 +0000
@@ -67,6 +67,8 @@
 					__FILE__, __FUNCTION__ , ## arg); \
 } while (0)
 
+#define PRINTABLE_STR(s) ((s) ? (s) : "(null)")
+
 #ifdef __cplusplus
 }
 #endif
 
=== added file 'include/system-settings.h'
--- include/system-settings.h	1970-01-01 00:00:00 +0000
+++ include/system-settings.h	2016-03-14 09:03:03 +0000
@@ -0,0 +1,51 @@
+/*
+ *
+ *  oFono - Open Telephony stack for Linux
+ *
+ *  Copyright (C) 2016  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_SYSTEM_SETTINGS_H
+#define OFONO_SYSTEM_SETTINGS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Settings names */
+#define PREFERRED_VOICE_MODEM "PreferredVoiceModem"
+
+struct ofono_system_settings_driver {
+	const char *name;
+	/* The user must free the returned string */
+	char *(*get_string_value)(const char *name);
+};
+
+/* The user must free the returned string */
+char *__ofono_system_settings_get_string_value(const char *name);
+
+int ofono_system_settings_driver_register(
+			struct ofono_system_settings_driver *driver);
+
+void ofono_system_settings_driver_unregister(
+			const struct ofono_system_settings_driver *driver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OFONO_SYSTEM_SETTINGS_H */
 
=== added file 'include/wakelock.h'
--- include/wakelock.h	1970-01-01 00:00:00 +0000
+++ include/wakelock.h	2016-03-14 09:03:03 +0000
@@ -0,0 +1,100 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2015 Jolla Ltd. All rights reserved.
+ *  Contact: Hannu Mallat <[e-mail]>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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_WAKELOCK_H_
+#define __OFONO_WAKELOCK_H_
+
+#include <ofono/types.h>
+
+/* Wakelock interface
+ *
+ * Wakelocks ensure system does not suspend/enter power save mode
+ * before an ongoing operation completes. This header declares a
+ * wakelock API that can be implemented by a OS-specific plugin.
+ */
+
+struct wakelock; /* Opaque */
+
+struct wakelock_table {
+	int (*create)(const char *name, struct wakelock **);
+	int (*free)(struct wakelock *);
+	int (*acquire)(struct wakelock *);
+	int (*release)(struct wakelock *);
+	ofono_bool_t (*is_locked)(struct wakelock *);
+};
+
+
+/*** Functions for wakelock users ***/
+
+/*
+ * This will create a wakelock which will be held for a short duration
+ * and then automatically freed. If this is called multiple times the
+ * timeout will be restarted on every call.
+ */
+void wakelock_system_lock(void);
+
+/*
+ * Create a wakelock. Multiple wakelocks can be created; if any one of
+ * them is activated, system will be prevented from going to suspend.
+ * This makes it possible to overlap locks to hand over from subsystem
+ * to subsystem, each with their own wakelock-guarded sections,
+ * without falling to suspend in between.
+ */
+int wakelock_create(const char *name, struct wakelock **wakelock);
+
+/*
+ * Free a wakelock, releasing all acquisitions at the same time
+ * and deallocating the lock.
+ */
+int wakelock_free(struct wakelock *wakelock);
+
+/*
+ * Acquire a wakelock. Multiple acquisitions are possible, meaning
+ * that the wakelock needs to be released the same number of times
+ * until it is actually deactivated.
+ */
+int wakelock_acquire(struct wakelock *wakelock);
+
+/*
+ * Release a wakelock, deactivating it if all acquisitions are
+ * released, letting system suspend.
+ */
+int wakelock_release(struct wakelock *wakelock);
+
+/*
+ * Check if a wakelock is currently locked or not.
+ */
+ofono_bool_t wakelock_is_locked(struct wakelock *wakelock);
+
+/*** Functions for wakelock implementors ***/
+
+/*
+ * Register a wakelock implementation. Only one implementation may be
+ * registered at a time. In the absence of an implementation, all
+ * wakelock functions are no-ops.
+ */
+int wakelock_plugin_register(const char *name, struct wakelock_table *fns);
+
+int wakelock_plugin_unregister(void);
+
+#endif
 
=== removed file 'include/wakelock.h'
--- include/wakelock.h	2016-01-15 16:03:09 +0000
+++ include/wakelock.h	1970-01-01 00:00:00 +0000
@@ -1,100 +0,0 @@
-/*
- *
- *  oFono - Open Source Telephony
- *
- *  Copyright (C) 2015 Jolla Ltd. All rights reserved.
- *  Contact: Hannu Mallat <[e-mail]>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  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_WAKELOCK_H_
-#define __OFONO_WAKELOCK_H_
-
-#include <ofono/types.h>
-
-/* Wakelock interface
- *
- * Wakelocks ensure system does not suspend/enter power save mode
- * before an ongoing operation completes. This header declares a
- * wakelock API that can be implemented by a OS-specific plugin.
- */
-
-struct wakelock; /* Opaque */
-
-struct wakelock_table {
-	int (*create)(const char *name, struct wakelock **);
-	int (*free)(struct wakelock *);
-	int (*acquire)(struct wakelock *);
-	int (*release)(struct wakelock *);
-	ofono_bool_t (*is_locked)(struct wakelock *);
-};
-
-
-/*** Functions for wakelock users ***/
-
-/*
- * This will create a wakelock which will be held for a short duration
- * and then automatically freed. If this is called multiple times the
- * timeout will be restarted on every call.
- */
-void wakelock_system_lock(void);
-
-/*
- * Create a wakelock. Multiple wakelocks can be created; if any one of
- * them is activated, system will be prevented from going to suspend.
- * This makes it possible to overlap locks to hand over from subsystem
- * to subsystem, each with their own wakelock-guarded sections,
- * without falling to suspend in between.
- */
-int wakelock_create(const char *name, struct wakelock **wakelock);
-
-/*
- * Free a wakelock, releasing all acquisitions at the same time
- * and deallocating the lock.
- */
-int wakelock_free(struct wakelock *wakelock);
-
-/*
- * Acquire a wakelock. Multiple acquisitions are possible, meaning
- * that the wakelock needs to be released the same number of times
- * until it is actually deactivated.
- */
-int wakelock_acquire(struct wakelock *wakelock);
-
-/*
- * Release a wakelock, deactivating it if all acquisitions are
- * released, letting system suspend.
- */
-int wakelock_release(struct wakelock *wakelock);
-
-/*
- * Check if a wakelock is currently locked or not.
- */
-ofono_bool_t wakelock_is_locked(struct wakelock *wakelock);
-
-/*** Functions for wakelock implementors ***/
-
-/*
- * Register a wakelock implementation. Only one implementation may be
- * registered at a time. In the absence of an implementation, all
- * wakelock functions are no-ops.
- */
-int wakelock_plugin_register(const char *name, struct wakelock_table *fns);
-
-int wakelock_plugin_unregister(void);
-
-#endif
 
=== added file 'plugins/accounts-settings.c'
--- plugins/accounts-settings.c	1970-01-01 00:00:00 +0000
+++ plugins/accounts-settings.c	2016-03-14 09:03:03 +0000
@@ -0,0 +1,474 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C)  2016 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 <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <sys/types.h>
+#include <pwd.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include <glib.h>
+#include <gdbus.h>
+#include <systemd/sd-login.h>
+
+#include <ofono.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+#include <ofono/types.h>
+#include <ofono/log.h>
+#include <ofono/plugin.h>
+#include <ofono/system-settings.h>
+
+#define ACCOUNTS_SERVICE          "org.freedesktop.Accounts"
+#define ACCOUNTS_PATH             "/org/freedesktop/Accounts/User"
+#define ACCOUNTS_PHONE_INTERFACE  "com.ubuntu.touch.AccountsService.Phone"
+#define DBUS_PROPERTIES_INTERFACE "org.freedesktop.DBus.Properties"
+
+struct setting {
+	char* ofono_name;
+	char* property_name;
+};
+
+static const struct setting setting_names[] = {
+	{ PREFERRED_VOICE_MODEM, "DefaultSimForCalls" }
+};
+
+#define NUM_SETTINGS G_N_ELEMENTS(setting_names)
+
+struct accounts_data {
+	sd_login_monitor *login_monitor;
+	guint login_watch;
+	char *property_values[NUM_SETTINGS];
+	uid_t current_uid;
+	guint prop_change_watch;
+	char uid_path[sizeof(ACCOUNTS_PATH) + 32];
+};
+
+static struct accounts_data g_accounts;
+
+static int translate_name(const char *name)
+{
+	size_t i;
+
+	for (i = 0; i < NUM_SETTINGS; ++i) {
+		if (g_strcmp0(setting_names[i].ofono_name, name) != 0)
+			continue;
+
+		return i;
+	}
+
+	return -1;
+}
+
+static char *accounts_settings_get_string_value(const char *name)
+{
+	int id;
+
+	id = translate_name(name);
+	if (id < 0)
+		return NULL;
+
+	return g_strdup(g_accounts.property_values[id]);
+}
+
+static struct ofono_system_settings_driver accounts_settings_driver = {
+	.name	 = "Accounts Service System Settings",
+	.get_string_value = accounts_settings_get_string_value
+};
+
+static int get_id_from_name(const char *name)
+{
+	size_t i;
+
+	for (i = 0; i < NUM_SETTINGS; ++i) {
+		if (g_strcmp0(setting_names[i].property_name, name) != 0)
+			continue;
+
+		return i;
+	}
+
+	return -1;
+}
+
+static char *get_property_value(DBusMessage *reply)
+{
+	DBusMessageIter iter, val;
+	const char *ptr;
+	char *property = NULL;
+
+	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+		ofono_error("%s: ERROR reply to Get", __func__);
+		goto done;
+	}
+
+	if (dbus_message_iter_init(reply, &iter) == FALSE) {
+		ofono_error("%s: error initializing array iter", __func__);
+		goto done;
+	}
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
+		ofono_error("%s: type != VARIANT!", __func__);
+		goto done;
+	}
+
+	dbus_message_iter_recurse(&iter, &val);
+
+	if (dbus_message_iter_get_arg_type(&val) != DBUS_TYPE_STRING) {
+		ofono_error("%s: type != STRING!", __func__);
+		goto done;
+	}
+
+	dbus_message_iter_get_basic(&val, &ptr);
+
+	property = g_strdup(ptr);
+
+done:
+	return property;
+}
+
+struct get_property_data {
+	struct accounts_data *accounts;
+	int prop_id;
+};
+
+static void get_property_reply(DBusPendingCall *call, void *user_data)
+{
+	DBusMessage *reply;
+	struct get_property_data *gpd = user_data;
+	char **values = gpd->accounts->property_values;
+	int id = gpd->prop_id;
+
+	reply = dbus_pending_call_steal_reply(call);
+	if (reply == NULL) {
+		ofono_error("%s: failed to get reply", __func__);
+		goto done;
+	}
+
+	g_free(values[id]);
+	values[id] = get_property_value(reply);
+	dbus_message_unref(reply);
+
+	DBG("property %s has value %s",
+		setting_names[id].property_name, PRINTABLE_STR(values[id]));
+
+done:
+	dbus_pending_call_unref(call);
+	g_free(gpd);
+}
+
+static void get_property(struct accounts_data *accounts, int id)
+{
+	DBusMessageIter iter;
+	DBusMessage *msg;
+	const char *iface = ACCOUNTS_PHONE_INTERFACE;
+	DBusConnection *conn = ofono_dbus_get_connection();
+	DBusPendingCall *call;
+	struct get_property_data *gpd;
+
+	msg = dbus_message_new_method_call(ACCOUNTS_SERVICE, accounts->uid_path,
+						DBUS_PROPERTIES_INTERFACE,
+						"Get");
+	if (msg == NULL) {
+		ofono_error("%s: dbus_message_new_method failed", __func__);
+		return;
+	}
+
+	dbus_message_iter_init_append(msg, &iter);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &iface);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
+					&setting_names[id].property_name);
+
+	if (!dbus_connection_send_with_reply(conn, msg, &call, -1)) {
+		ofono_error("%s: Sending Get failed", __func__);
+		goto done;
+	}
+
+	gpd = g_malloc0(sizeof(*gpd));
+	gpd->accounts = accounts;
+	gpd->prop_id = id;
+	dbus_pending_call_set_notify(call, get_property_reply, gpd, NULL);
+
+done:
+	dbus_message_unref(msg);
+}
+
+static gboolean property_changed(DBusConnection *conn,
+					DBusMessage *msg, void *user_data)
+{
+	struct accounts_data *accounts = user_data;
+	const char *iface;
+	DBusMessageIter iter, dict, inv_it;
+
+	dbus_message_iter_init(msg, &iter);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
+		ofono_error("%s: iface != TYPE_STRING!", __func__);
+		goto done;
+	}
+
+	dbus_message_iter_get_basic(&iter, &iface);
+
+	/* We can receive notifications from other AccountsService interfaces */
+	if (g_str_equal(iface, ACCOUNTS_PHONE_INTERFACE) != TRUE)
+		goto done;
+
+	if (!dbus_message_iter_next(&iter)) {
+		ofono_error("%s: advance iter failed!", __func__);
+		goto done;
+	}
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) {
+		ofono_error("%s: type != ARRAY!", __func__);
+		goto done;
+	}
+
+	dbus_message_iter_recurse(&iter, &dict);
+
+	while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+		DBusMessageIter entry, val;
+		const char *key, *str_val;
+		int id;
+
+		dbus_message_iter_recurse(&dict, &entry);
+
+		if (dbus_message_iter_get_arg_type(&entry) !=
+				DBUS_TYPE_STRING) {
+			ofono_error("%s: key type != STRING!", __func__);
+			goto done;
+		}
+
+		dbus_message_iter_get_basic(&entry, &key);
+
+		dbus_message_iter_next(&entry);
+
+		if (dbus_message_iter_get_arg_type(&entry) !=
+				DBUS_TYPE_VARIANT) {
+			ofono_error("%s: val != VARIANT", __func__);
+			goto done;
+		}
+
+		dbus_message_iter_recurse(&entry, &val);
+
+		if (dbus_message_iter_get_arg_type(&val) != DBUS_TYPE_STRING) {
+			ofono_error("%s: *val != STRING", __func__);
+			goto done;
+		}
+
+		dbus_message_iter_get_basic(&val, &str_val);
+
+		DBG("property %s changed to %s", key, PRINTABLE_STR(str_val));
+
+		id = get_id_from_name(key);
+		if (id >= 0)
+			accounts->property_values[id] = g_strdup(str_val);
+
+		dbus_message_iter_next(&dict);
+	}
+
+	/* Check invalidated properties */
+	if (!dbus_message_iter_next(&iter)) {
+		ofono_error("%s: advance iter failed!", __func__);
+		goto done;
+	}
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) {
+		ofono_error("%s: type != ARRAY!", __func__);
+		goto done;
+	}
+
+	dbus_message_iter_recurse(&iter, &inv_it);
+
+	while (dbus_message_iter_get_arg_type(&inv_it) == DBUS_TYPE_STRING) {
+		const char *inv_name;
+		int id;
+
+		dbus_message_iter_get_basic(&inv_it, &inv_name);
+
+		DBG("property %s invalidated", inv_name);
+
+		id = get_id_from_name(inv_name);
+		if (id >= 0)
+			get_property(accounts, id);
+
+		dbus_message_iter_next(&inv_it);
+	}
+
+done:
+	return TRUE;
+}
+
+static void get_user_settings(struct accounts_data *accounts)
+{
+	DBusConnection *conn = ofono_dbus_get_connection();
+	size_t i;
+
+	snprintf(accounts->uid_path, sizeof(accounts->uid_path),
+			ACCOUNTS_PATH"%u", (unsigned) accounts->current_uid);
+
+	/*
+	 * Register for property changes. Note that AccountsService is D-Bus,
+	 * initiated, so there is no risk for race conditions on start.
+	 */
+	accounts->prop_change_watch =
+		g_dbus_add_signal_watch(conn, ACCOUNTS_SERVICE,
+						accounts->uid_path,
+						DBUS_INTERFACE_PROPERTIES,
+						"PropertiesChanged",
+						property_changed,
+						accounts, NULL);
+
+	/* Retrieve AccountService properties */
+	for (i = 0; i < NUM_SETTINGS; ++i)
+		get_property(accounts, i);
+}
+
+static void release_accounts_data(struct accounts_data *accounts)
+{
+	DBusConnection *conn = ofono_dbus_get_connection();
+	size_t i;
+
+	g_dbus_remove_watch(conn, accounts->prop_change_watch);
+
+	for (i = 0; i < NUM_SETTINGS; ++i) {
+		g_free(accounts->property_values[i]);
+		accounts->property_values[i] = NULL;
+	}
+}
+
+static uid_t get_active_seat_uid(void)
+{
+	char **seats, **iter;
+	int res;
+	gboolean found = FALSE;
+	uid_t uid;
+
+	res = sd_get_seats(&seats);
+	if (res < 0) {
+		ofono_error("Error retrieving seats: %s (%d)",
+							strerror(-res), -res);
+		goto end;
+	} else if (res == 0) {
+		ofono_info("No seats found");
+		goto end;
+	}
+
+	for (iter = seats; *iter; ++iter) {
+
+		if (!found && sd_seat_get_active(*iter, NULL, &uid) >= 0) {
+			DBG("seat %s with uid %d", *iter, uid);
+			found = TRUE;
+		}
+
+		free(*iter);
+	}
+
+	free(seats);
+
+end:
+	if (!found)
+		uid = geteuid();
+
+	return uid;
+}
+
+static gboolean sd_changed(GIOChannel *stream, GIOCondition condition,
+							gpointer user_data)
+{
+	struct accounts_data *accounts = user_data;
+	uid_t new_uid;
+
+	sd_login_monitor_flush(accounts->login_monitor);
+
+	new_uid = get_active_seat_uid();
+	if (new_uid != accounts->current_uid) {
+		/* User in seat changed, resetting data */
+		release_accounts_data(accounts);
+
+		accounts->current_uid = new_uid;
+		get_user_settings(accounts);
+	}
+
+	return TRUE;
+}
+
+static void sd_init(struct accounts_data *accounts)
+{
+	int status;
+	GIOChannel *stream;
+	int fd;
+
+	status = sd_login_monitor_new(NULL, &accounts->login_monitor);
+	if (status < 0) {
+		ofono_error("Error creating systemd login monitor: %d", status);
+		accounts->login_monitor = NULL;
+		return;
+	}
+
+	fd = sd_login_monitor_get_fd(accounts->login_monitor);
+	stream = g_io_channel_unix_new(fd);
+	accounts->login_watch =
+			g_io_add_watch(stream, G_IO_IN, sd_changed, accounts);
+
+	g_io_channel_unref(stream);
+}
+
+static void sd_finalize(struct accounts_data *accounts)
+{
+	if (accounts->login_monitor == NULL)
+		return;
+
+	g_source_remove(accounts->login_watch);
+	sd_login_monitor_unref(accounts->login_monitor);
+}
+
+static int accounts_settings_init(void)
+{
+	g_accounts.current_uid = get_active_seat_uid();
+
+	/* Register for login changes */
+	sd_init(&g_accounts);
+
+	/* Get property values for current user */
+	get_user_settings(&g_accounts);
+
+	return ofono_system_settings_driver_register(&accounts_settings_driver);
+}
+
+static void accounts_settings_exit(void)
+{
+	ofono_system_settings_driver_unregister(&accounts_settings_driver);
+
+	sd_finalize(&g_accounts);
+
+	release_accounts_data(&g_accounts);
+}
+
+OFONO_PLUGIN_DEFINE(accounts_settings,
+			"Accounts Service System Settings Plugin",
+			VERSION, OFONO_PLUGIN_PRIORITY_DEFAULT,
+			accounts_settings_init, accounts_settings_exit)
 
=== added file 'plugins/android-wakelock.c'
--- plugins/android-wakelock.c	1970-01-01 00:00:00 +0000
+++ plugins/android-wakelock.c	2016-03-14 09:03:03 +0000
@@ -0,0 +1,212 @@
+/*
+ *
+ *  oFono - Open Source Telephony - Android based wakelocks
+ *
+ *  Copyright (C) 2016 Canonical Ltd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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 <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <glib.h>
+#include <dlfcn.h>
+
+#include <glib.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+
+#include "plugin.h"
+#include "log.h"
+#include "wakelock.h"
+
+#define ANDROID_WAKELOCK_LOCK_PATH		"/sys/power/wake_lock"
+#define ANDROID_WAKELOCK_UNLOCK_PATH	"/sys/power/wake_unlock"
+
+struct wakelock {
+	char *name;
+	unsigned int acquisitions;
+};
+
+GSList *locks = NULL;
+
+static int file_exists(char const *filename)
+{
+	struct stat st;
+
+	return stat(filename, &st) == 0;
+}
+
+static int write_file(const char *file, const char *content)
+{
+	int fd;
+	unsigned int r = 0;
+
+	fd = open(file, O_WRONLY);
+
+	if (fd == -1)
+		return -EIO;
+
+	r = write(fd, content, strlen(content));
+
+	close(fd);
+
+	if (r != strlen(content))
+		return -EIO;
+
+	return 0;
+}
+
+static int wakelock_lock(const char *name)
+{
+	return write_file(ANDROID_WAKELOCK_LOCK_PATH, name);
+}
+
+static int wakelock_unlock(const char *name)
+{
+	return write_file(ANDROID_WAKELOCK_UNLOCK_PATH, name);
+}
+
+static int android_wakelock_acquire(struct wakelock *lock)
+{
+	if (lock == NULL)
+		return -EINVAL;
+
+	if (lock->acquisitions > 0) {
+		lock->acquisitions++;
+		return 0;
+	}
+
+	if (wakelock_lock(lock->name) < 0)
+		return -EIO;
+
+	lock->acquisitions++;
+
+	return 0;
+}
+
+static int android_wakelock_release(struct wakelock *lock)
+{
+	if (lock == NULL)
+		return -EINVAL;
+
+	DBG("lock %p name %s acquisitions %d",
+		lock, lock->name, lock->acquisitions);
+
+	if (!lock->acquisitions) {
+		ofono_warn("Attempted to release already released lock %s", lock->name);
+		return -EINVAL;
+	}
+
+	if (lock->acquisitions > 1) {
+		lock->acquisitions--;
+		DBG("lock %s released acquisitions %d", lock->name, lock->acquisitions);
+		return 0;
+	}
+
+	if (wakelock_unlock(lock->name) < 0)
+		return -EIO;
+
+	lock->acquisitions = 0;
+
+	DBG("lock %s was released", lock->name);
+
+	return 0;
+}
+
+static int android_wakelock_create(const char *name, struct wakelock **lock)
+{
+	if (lock == NULL)
+		return -EINVAL;
+
+	*lock = g_new0(struct wakelock, 1);
+	(*lock)->name = g_strdup(name);
+	(*lock)->acquisitions = 0;
+
+	locks = g_slist_prepend(locks, *lock);
+
+	DBG("wakelock %s create", name);
+
+	return 0;
+}
+
+static int android_wakelock_free(struct wakelock *lock)
+{
+	if (lock == NULL)
+		return -EINVAL;
+
+	if (lock->acquisitions) {
+		/* Need to force releasing the lock here */
+		lock->acquisitions = 1;
+		android_wakelock_release(lock);
+	}
+
+	locks = g_slist_remove(locks, lock);
+
+	DBG("Freeing lock %s", lock->name);
+
+	g_free(lock->name);
+	g_free(lock);
+
+	return 0;
+}
+
+static ofono_bool_t android_wakelock_is_locked(struct wakelock *lock)
+{
+	if (lock == NULL)
+		return FALSE;
+
+	return lock->acquisitions > 0;
+}
+
+struct wakelock_table driver = {
+	.create = android_wakelock_create,
+	.free = android_wakelock_free,
+	.acquire = android_wakelock_acquire,
+	.release = android_wakelock_release,
+	.is_locked = android_wakelock_is_locked
+};
+
+static int android_wakelock_init(void)
+{
+	if (!file_exists(ANDROID_WAKELOCK_LOCK_PATH)) {
+		ofono_warn("System does not support Android wakelocks.");
+		return 0;
+	}
+
+	if (wakelock_plugin_register("android-wakelock", &driver) < 0) {
+		ofono_error("Failed to register wakelock driver");
+		return -EIO;
+	}
+
+	return 0;
+}
+
+static void android_wakelock_exit(void)
+{
+	wakelock_plugin_unregister();
+}
+
+OFONO_PLUGIN_DEFINE(android_wakelock, "Android Wakelock driver", VERSION,
+			OFONO_PLUGIN_PRIORITY_DEFAULT, android_wakelock_init, android_wakelock_exit)
 
=== removed file 'plugins/android-wakelock.c'
--- plugins/android-wakelock.c	2016-01-15 16:03:09 +0000
+++ plugins/android-wakelock.c	1970-01-01 00:00:00 +0000
@@ -1,212 +0,0 @@
-/*
- *
- *  oFono - Open Source Telephony - Android based wakelocks
- *
- *  Copyright (C) 2016 Canonical Ltd.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  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 <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <glib.h>
-#include <dlfcn.h>
-
-#include <glib.h>
-
-#define OFONO_API_SUBJECT_TO_CHANGE
-
-#include "plugin.h"
-#include "log.h"
-#include "wakelock.h"
-
-#define ANDROID_WAKELOCK_LOCK_PATH		"/sys/power/wake_lock"
-#define ANDROID_WAKELOCK_UNLOCK_PATH	"/sys/power/wake_unlock"
-
-struct wakelock {
-	char *name;
-	unsigned int acquisitions;
-};
-
-GSList *locks = NULL;
-
-static int file_exists(char const *filename)
-{
-	struct stat st;
-
-	return stat(filename, &st) == 0;
-}
-
-static int write_file(const char *file, const char *content)
-{
-	int fd;
-	unsigned int r = 0;
-
-	fd = open(file, O_WRONLY);
-
-	if (fd == -1)
-		return -EIO;
-
-	r = write(fd, content, strlen(content));
-
-	close(fd);
-
-	if (r != strlen(content))
-		return -EIO;
-
-	return 0;
-}
-
-static int wakelock_lock(const char *name)
-{
-	return write_file(ANDROID_WAKELOCK_LOCK_PATH, name);
-}
-
-static int wakelock_unlock(const char *name)
-{
-	return write_file(ANDROID_WAKELOCK_UNLOCK_PATH, name);
-}
-
-static int android_wakelock_acquire(struct wakelock *lock)
-{
-	if (!lock)
-		return -EINVAL;
-
-	if (lock->acquisitions > 0) {
-		lock->acquisitions++;
-		return 0;
-	}
-
-	if (wakelock_lock(lock->name) < 0)
-		return -EIO;
-
-	lock->acquisitions++;
-
-	return 0;
-}
-
-static int android_wakelock_release(struct wakelock *lock)
-{
-	if (!lock)
-		return -EINVAL;
-
-	DBG("lock %p name %s acquisitions %d",
-		lock, lock->name, lock->acquisitions);
-
-	if (!lock->acquisitions) {
-		ofono_warn("Attempted to release already released lock %s", lock->name);
-		return -EINVAL;
-	}
-
-	if (lock->acquisitions > 1) {
-		lock->acquisitions--;
-		DBG("lock %s released acquisitions %d", lock->name, lock->acquisitions);
-		return 0;
-	}
-
-	if (wakelock_unlock(lock->name) < 0)
-		return -EIO;
-
-	lock->acquisitions = 0;
-
-	DBG("lock %s was released", lock->name);
-
-	return 0;
-}
-
-static int android_wakelock_create(const char *name, struct wakelock **lock)
-{
-	if (!lock)
-		return -EINVAL;
-
-	*lock = g_new0(struct wakelock, 1);
-	(*lock)->name = g_strdup(name);
-	(*lock)->acquisitions = 0;
-
-	locks = g_slist_prepend(locks, *lock);
-
-	DBG("wakelock %s create", name);
-
-	return 0;
-}
-
-static int android_wakelock_free(struct wakelock *lock)
-{
-	if (!lock)
-		return -EINVAL;
-
-	if (lock->acquisitions) {
-		/* Need to force releasing the lock here */
-		lock->acquisitions = 1;
-		android_wakelock_release(lock);
-	}
-
-	locks = g_slist_remove(locks, lock);
-
-	DBG("Freeing lock %s", lock->name);
-
-	g_free(lock->name);
-	g_free(lock);
-
-	return 0;
-}
-
-static ofono_bool_t android_wakelock_is_locked(struct wakelock *lock)
-{
-	if (!lock)
-		return FALSE;
-
-	return lock->acquisitions > 0;
-}
-
-struct wakelock_table driver = {
-	.create = android_wakelock_create,
-	.free = android_wakelock_free,
-	.acquire = android_wakelock_acquire,
-	.release = android_wakelock_release,
-	.is_locked = android_wakelock_is_locked
-};
-
-static int android_wakelock_init(void)
-{
-	if (!file_exists(ANDROID_WAKELOCK_LOCK_PATH)) {
-		ofono_warn("System does not support Android wakelocks.");
-		return 0;
-	}
-
-	if (wakelock_plugin_register("android-wakelock", &driver) < 0) {
-		ofono_error("Failed to register wakelock driver");
-		return -EIO;
-	}
-
-	return 0;
-}
-
-static void android_wakelock_exit(void)
-{
-	wakelock_plugin_unregister();
-}
-
-OFONO_PLUGIN_DEFINE(android_wakelock, "Android Wakelock driver", VERSION,
-			OFONO_PLUGIN_PRIORITY_DEFAULT, android_wakelock_init, android_wakelock_exit)
 
=== modified file 'plugins/qcom-msim.c'
--- plugins/qcom-msim.c	2015-04-23 13:08:30 +0000
+++ plugins/qcom-msim.c	2016-03-14 09:03:03 +0000
@@ -36,6 +36,18 @@
 
 static int qcom_msim_probe(struct ofono_modem *modem)
 {
+	int slot_id = ofono_modem_get_integer(modem, "Slot");
+
+	/* qcom_msim has socket path "rild", "rild1", ... */
+	if (slot_id != 0) {
+		char *socket;
+
+		socket = g_strdup_printf("/dev/socket/rild%d", slot_id);
+		ofono_modem_set_string(modem, "Socket", socket);
+
+		g_free(socket);
+	}
+
 	return ril_create(modem, OFONO_RIL_VENDOR_QCOM_MSIM);
 }
 
 
=== modified file 'plugins/ril.c'
--- plugins/ril.c	2015-10-07 07:14:11 +0000
+++ plugins/ril.c	2016-03-14 09:03:03 +0000
@@ -73,9 +73,6 @@
 #define RILD_MAX_CONNECT_RETRIES 5
 #define RILD_CONNECT_RETRY_TIME_S 5
 
-char *RILD_CMD_SOCKET[] = {"/dev/socket/rild", "/dev/socket/rild1"};
-char *GRIL_HEX_PREFIX[] = {"Device 0: ", "Device 1: "};
-
 struct ril_data {
 	GRil *ril;
 	enum ofono_ril_vendor vendor;
@@ -90,9 +87,9 @@
 
 static void ril_debug(const char *str, void *user_data)
 {
-	const char *prefix = user_data;
+	struct ril_data *rd = user_data;
 
-	ofono_info("%s%s", prefix, str);
+	ofono_info("Device %d: %s", g_ril_get_slot(rd->ril), str);
 }
 
 static void ril_radio_state_changed(struct ril_msg *message, gpointer user_data)
@@ -169,7 +166,7 @@
 
 	rd->vendor = vendor;
 	rd->ofono_online = FALSE;
-	rd->radio_state = RADIO_STATE_OFF;
+	rd->radio_state = RADIO_STATE_UNAVAILABLE;
 
 	lte_cap = getenv("OFONO_RIL_RAT_LTE") ? TRUE : FALSE;
 	ofono_modem_set_boolean(modem, MODEM_PROP_LTE_CAPABLE, lte_cap);
@@ -284,7 +281,9 @@
 	struct ril_data *rd = cbd->user;
 	ofono_modem_online_cb_t cb = cbd->cb;
 
-	if (message->error == RIL_E_SUCCESS) {
+	if (message != NULL && message->error == RIL_E_SUCCESS) {
+		g_ril_print_response_no_args(rd->ril, message);
+
 		DBG("%s: set_online OK: rd->ofono_online: %d", __func__,
 			rd->ofono_online);
 		CALLBACK_WITH_SUCCESS(cb, cbd->data);
@@ -293,31 +292,24 @@
 				rd->ofono_online);
 		CALLBACK_WITH_FAILURE(cb, cbd->data);
 	}
+
+	g_free(cbd);
 }
 
 static void ril_send_power(struct ril_data *rd, ofono_bool_t online,
 				GRilResponseFunc func,
 				gpointer user_data)
 {
-	struct cb_data *cbd = user_data;
-	ofono_modem_online_cb_t cb;
-	GDestroyNotify notify = NULL;
 	struct parcel rilp;
 
-	if (cbd != NULL) {
-		notify = g_free;
-		cb = cbd->cb;
-	}
-
 	DBG("(online = 1, offline = 0)): %i", online);
 
 	g_ril_request_power(rd->ril, (const gboolean) online, &rilp);
 
 	if (g_ril_send(rd->ril, RIL_REQUEST_RADIO_POWER, &rilp,
-			func, cbd, notify) == 0 && cbd != NULL) {
+			func, user_data, NULL) == 0 && func != NULL) {
 
-		CALLBACK_WITH_FAILURE(cb, cbd->data);
-		g_free(cbd);
+		func(NULL, user_data);
 	}
 }
 
@@ -334,30 +326,47 @@
 	ril_send_power(rd, online, ril_set_online_cb, cbd);
 }
 
+static void ril_set_powered_off_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_modem *modem = user_data;
+	struct ril_data *rd = ofono_modem_get_data(modem);
+
+	if (message != NULL && message->error == RIL_E_SUCCESS)
+		g_ril_print_response_no_args(rd->ril, message);
+
+	DBG("calling set_powered(TRUE)");
+
+	ofono_modem_set_powered(modem, TRUE);
+}
+
 static void ril_connected(struct ril_msg *message, gpointer user_data)
 {
 	struct ofono_modem *modem = (struct ofono_modem *) user_data;
 	struct ril_data *rd = ofono_modem_get_data(modem);
-
-	ofono_info("[%d,UNSOL]< %s", g_ril_get_slot(rd->ril),
-		g_ril_unsol_request_to_string(rd->ril, message->req));
+	int version;
+
+	version = g_ril_unsol_parse_connected(rd->ril, message);
+	g_ril_set_version(rd->ril, version);
+
+	ofono_info("[%d,UNSOL]< %s, version %d", g_ril_get_slot(rd->ril),
+		g_ril_unsol_request_to_string(rd->ril, message->req), version);
 
 	/* TODO: need a disconnect function to restart things! */
 	rd->connected = TRUE;
 
-	DBG("calling set_powered(TRUE)");
+	DBG("calling set_powered(FALSE) on connected");
 
-	ofono_modem_set_powered(modem, TRUE);
+	ril_send_power(rd, FALSE, ril_set_powered_off_cb, modem);
 }
 
 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");
+	const gchar *socket = ofono_modem_get_string(modem, "Socket");
 
-	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);
+	ofono_info("Using %s as socket for slot %d.", socket, slot_id);
+	rd->ril = g_ril_new(socket, rd->vendor);
 
 	/* NOTE: Since AT modems open a tty, and then call
 	 * g_at_chat_new(), they're able to return -EIO if
@@ -377,7 +386,7 @@
 		g_ril_set_trace(rd->ril, TRUE);
 
 	if (getenv("OFONO_RIL_HEX_TRACE"))
-		g_ril_set_debugf(rd->ril, ril_debug, GRIL_HEX_PREFIX[slot_id]);
+		g_ril_set_debugf(rd->ril, ril_debug, rd);
 
 	g_ril_register(rd->ril, RIL_UNSOL_RIL_CONNECTED,
 			ril_connected, modem);
 
=== modified file 'plugins/rildev.c'
--- plugins/rildev.c	2015-11-10 09:13:46 +0000
+++ plugins/rildev.c	2016-03-14 09:03:03 +0000
@@ -43,6 +43,7 @@
 {
 	struct ofono_modem *modem;
 	char dev_name[64];
+	char *socket;
 	int retval;
 
 	snprintf(dev_name, sizeof(dev_name), "ril_%d", slot);
@@ -58,6 +59,15 @@
 
 	ofono_modem_set_integer(modem, "Slot", slot);
 
+	/* AOSP has socket path "rild", "rild2"..., while others may differ */
+	if (slot != 0)
+		socket = g_strdup_printf("/dev/socket/rild%d", slot + 1);
+	else
+		socket = g_strdup("/dev/socket/rild");
+
+	ofono_modem_set_string(modem, "Socket", socket);
+	g_free(socket);
+
 	/* This causes driver->probe() to be called... */
 	retval = ofono_modem_register(modem);
 	if (retval != 0) {
 
=== modified file 'plugins/upower.c'
--- plugins/upower.c	2015-11-02 09:18:14 +0000
+++ plugins/upower.c	2016-03-14 09:03:03 +0000
@@ -40,11 +40,8 @@
 #define UPOWER_DEVICE_INTERFACE       UPOWER_SERVICE ".Device"
 
 static guint modem_watch;
-static guint upower_battery_watch;
 static guint upower_daemon_watch;
 static DBusConnection *connection;
-static GHashTable *modem_hfp_watches;
-static GList *modems;
 static int last_battery_level;
 static char *battery_device_path;
 
@@ -56,9 +53,17 @@
 	ofono_emulator_set_indicator(atom, OFONO_EMULATOR_IND_BATTERY, val);
 }
 
+static void update_modem_battery_indicator(struct ofono_modem *modem,
+								void *data)
+{
+	__ofono_modem_foreach_registered_atom(modem,
+				OFONO_ATOM_TYPE_EMULATOR_HFP,
+				emulator_battery_cb,
+				data);
+}
+
 static void update_battery_level(double percentage_val)
 {
-	GList *list;
 	int battery_level;
 
 	if (percentage_val <= 1.00) {
@@ -69,27 +74,19 @@
 		ofono_error("%s: Invalid value for battery level: %f",
 								__func__,
 								percentage_val);
-		goto done;
+		return;
 	}
 
 	DBG("last_battery_level: %d battery_level: %d (%f)", last_battery_level,
 						battery_level, percentage_val);
 
 	if (last_battery_level == battery_level)
-		goto done;
+		return;
 
 	last_battery_level = battery_level;
 
-	for (list = modems; list; list = list->next) {
-		struct ofono_modem *modem = list->data;
-
-		__ofono_modem_foreach_registered_atom(modem,
-					OFONO_ATOM_TYPE_EMULATOR_HFP,
-					emulator_battery_cb,
+	__ofono_modem_foreach(update_modem_battery_indicator,
 					GINT_TO_POINTER(battery_level));
-	}
-done:
-	;
 }
 
 static gboolean battery_props_changed(DBusConnection *conn, DBusMessage *msg,
@@ -102,6 +99,8 @@
 	gboolean percentage_found = FALSE;
 	gboolean retval = FALSE;
 
+	DBG("");
+
 	dbus_message_iter_init(msg, &iter);
 
 	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
@@ -179,117 +178,19 @@
 	return retval;
 }
 
-static void get_property_reply(DBusPendingCall *call, void *user_data)
-{
-	double percentage_val;
-	DBusMessageIter iter, val;
-	DBusMessage *reply;
-
-	DBG("");
-
-	reply = dbus_pending_call_steal_reply(call);
-	if (reply == NULL) {
-		ofono_error("%s: dbus_message_new_method failed", __func__);
-		goto done;
-	}
-
-	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
-		ofono_error("%s: ERROR reply to Get('Percentage')", __func__);
-		goto done;
-	}
-
-	if (dbus_message_iter_init(reply, &iter) == FALSE) {
-		ofono_error("%s: error initializing array iter", __func__);
-		goto done;
-	}
-
-	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
-		ofono_error("%s: type != VARIANT!", __func__);
-		goto done;
-	}
-
-	dbus_message_iter_recurse(&iter, &val);
-
-	if (dbus_message_iter_get_arg_type(&val) != DBUS_TYPE_DOUBLE) {
-		ofono_error("%s: type != DOUBLE!", __func__);
-		goto done;
-	}
-
-	dbus_message_iter_get_basic(&val, &percentage_val);
-
-	update_battery_level(percentage_val);
-
-done:
-	if (reply)
-		dbus_message_unref(reply);
-
-	dbus_pending_call_unref(call);
-}
-
 static void emulator_hfp_watch(struct ofono_atom *atom,
 				enum ofono_atom_watch_condition cond,
 				void *data)
 {
-	struct ofono_modem *modem = data;
-	DBusMessageIter iter;
-	DBusPendingCall *call;
-	DBusMessage *msg;
-	const char *iface = UPOWER_DEVICE_INTERFACE;
-	const char *property = "Percentage";
-
-	if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) {
-		DBG("UNREGISTERED");
-
-		modems = g_list_remove(modems, modem);
-		if (modems != NULL)
-			return;
-
-		if (upower_battery_watch) {
-			g_dbus_remove_watch(connection, upower_battery_watch);
-			upower_battery_watch = 0;
-		}
-
-		return;
-	}
-
-	DBG("REGISTERED");
-
-	/* TODO: handle removable batteries */
-
-	modems = g_list_append(modems, modem);
-
-	if (modems->next != NULL)
-		return;
-
-	upower_battery_watch = g_dbus_add_signal_watch(connection,
-						UPOWER_SERVICE,
-						battery_device_path,
-						DBUS_INTERFACE_PROPERTIES,
-						"PropertiesChanged",
-						battery_props_changed,
-						NULL, NULL);
-
-	/* Query current battery value */
-	msg = dbus_message_new_method_call(UPOWER_SERVICE, battery_device_path,
-						DBUS_PROPERTIES_INTERFACE,
-						"Get");
-	if (msg == NULL) {
-		ofono_error("%s: dbus_message_new_method failed", __func__);
-		return;
-	}
-
-	dbus_message_iter_init_append(msg, &iter);
-	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &iface);
-	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &property);
-
-	if (!dbus_connection_send_with_reply(connection, msg, &call, -1)) {
-		ofono_error("%s: Sending EnumerateDevices failed", __func__);
-		goto done;
-	}
-
-	dbus_pending_call_set_notify(call, get_property_reply, NULL, NULL);
-done:
-	dbus_message_unref(msg);
+	if (cond == OFONO_ATOM_WATCH_CONDITION_REGISTERED) {
+		DBG("REGISTERED; calling set_indicator: %d", last_battery_level);
+
+		ofono_emulator_set_indicator(atom, OFONO_EMULATOR_IND_BATTERY,
+							last_battery_level);
+		return;
+	}
+
+	DBG("UNREGISTERED");
 }
 
 static void modemwatch(struct ofono_modem *modem, gboolean added, void *user)
@@ -299,24 +200,10 @@
 
 	DBG("modem: %s, added: %d", path, added);
 
-	if (added) {
-		guint watch_id;
-
-		watch_id = __ofono_modem_add_atom_watch(modem,
+	if (added)
+		__ofono_modem_add_atom_watch(modem,
 					OFONO_ATOM_TYPE_EMULATOR_HFP,
-					emulator_hfp_watch, modem, NULL);
-
-		g_hash_table_insert(modem_hfp_watches, g_strdup(path),
-						GINT_TO_POINTER(watch_id));
-
-	} else {
-		guint *watch_id = g_hash_table_lookup(modem_hfp_watches, path);
-
-		if (watch_id != NULL) {
-			__ofono_modem_remove_atom_watch(modem, *watch_id);
-			g_hash_table_remove(modem_hfp_watches, path);
-		}
-	}
+					emulator_hfp_watch, NULL, NULL);
 }
 
 static void call_modemwatch(struct ofono_modem *modem, void *user)
@@ -383,13 +270,23 @@
 
 	DBG("parse_devices_reply OK");
 
+	/* TODO: handle removable batteries */
+
 	if (battery_device_path == NULL) {
 		ofono_error("%s: no battery detected", __func__);
 		goto done;
 	}
 
+	/* Always listen to PropertiesChanged for battery */
+	g_dbus_add_signal_watch(connection, UPOWER_SERVICE, battery_device_path,
+						DBUS_INTERFACE_PROPERTIES,
+						"PropertiesChanged",
+						battery_props_changed,
+						NULL, NULL);
+
 	modem_watch = __ofono_modemwatch_add(modemwatch, NULL, NULL);
 	__ofono_modem_foreach(call_modemwatch, NULL);
+
 done:
 	if (reply)
 		dbus_message_unref(reply);
@@ -449,9 +346,6 @@
 							upower_disconnect,
 							NULL, NULL);
 
-	modem_hfp_watches = g_hash_table_new_full(g_str_hash, g_str_equal,
-				g_free, NULL);
-
 	return 0;
 }
 
@@ -465,8 +359,6 @@
 
 	if (battery_device_path)
 		g_free(battery_device_path);
-
-	g_hash_table_destroy(modem_hfp_watches);
 }
 
 OFONO_PLUGIN_DEFINE(upower, "upower battery monitor", VERSION,
 
=== modified file 'src/emulator.c'
--- src/emulator.c	2015-11-27 16:53:45 +0000
+++ src/emulator.c	2016-03-14 09:03:03 +0000
@@ -37,6 +37,7 @@
 #include "gatserver.h"
 #include "gatppp.h"
 #include "handsfree-audio.h"
+#include "system-settings.h"
 
 #define RING_TIMEOUT 3
 
@@ -1448,14 +1449,35 @@
 
 static struct ofono_atom *get_preferred_atom(struct ofono_emulator *em)
 {
+	char *path;
+	GSList *l;
+	struct ofono_atom *preferred = em->atoms->data;
+
+	path = __ofono_system_settings_get_string_value(PREFERRED_VOICE_MODEM);
+	if (path == NULL)
+		goto end;
+
+	for (l = em->atoms; l; l = l->next) {
+		struct ofono_atom *atom = l->data;
+
+		if (g_strcmp0(__ofono_atom_get_path(atom), path) == 0) {
+			preferred = atom;
+			break;
+		}
+	}
+
+	g_free(path);
+
+end:
+	return preferred;
+}
+
+static struct ofono_atom *get_active_atom(struct ofono_emulator *em)
+{
 	if (em->active_atom)
 		return em->active_atom;
 
-	/*
-	 * TODO For the moment we just take the first on the list, we need to
-	 * ask the modem and have something configurable from settings.
-	 */
-	return em->atoms->data;
+	return get_preferred_atom(em);
 }
 
 static struct atom_callback *find_atom_callback(GSList *prefix_cbs,
@@ -1494,7 +1516,7 @@
 	struct ofono_emulator_request req;
 	struct ofono_atom *atom;
 
-	atom = get_preferred_atom(h->em);
+	atom = get_active_atom(h->em);
 	prefix_cbs = g_hash_table_lookup(h->em->prefixes, h->prefix);
 	atom_cb = find_atom_callback(prefix_cbs, atom);
 	if (atom_cb == NULL) {
@@ -1689,11 +1711,7 @@
 	}
 
 	/* Return FALSE if the modem is not the preferred one */
-	/*
-	 * TODO For the moment we just take the first on the list, we need to
-	 * ask the modem and have some configurable from settings.
-	 */
-	preferred = em->atoms->data;
+	preferred = get_preferred_atom(em);
 	if (preferred == atom)
 		return TRUE;
 	else
 
=== added file 'src/system-settings.c'
--- src/system-settings.c	1970-01-01 00:00:00 +0000
+++ src/system-settings.c	2016-03-14 09:03:03 +0000
@@ -0,0 +1,74 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2016  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 "system-settings.h"
+
+static GSList *g_drivers = NULL;
+
+char *__ofono_system_settings_get_string_value(const char *name)
+{
+	GSList *d;
+	char *value = NULL;
+
+	for (d = g_drivers; d != NULL; d = d->next) {
+		const struct ofono_system_settings_driver *driver = d->data;
+
+		if (driver->get_string_value == NULL)
+			continue;
+
+		DBG("Calling system settings plugin '%s'", driver->name);
+
+		value = driver->get_string_value(name);
+		if (value == NULL)
+			continue;
+
+		DBG("property %s value %s", name, value);
+
+		return value;
+	}
+
+	return value;
+}
+
+int ofono_system_settings_driver_register(
+			struct ofono_system_settings_driver *driver)
+{
+	DBG("driver: %p name: %s", driver, driver->name);
+
+	g_drivers = g_slist_prepend(g_drivers, driver);
+	return 0;
+}
+
+void ofono_system_settings_driver_unregister(
+			const struct ofono_system_settings_driver *driver)
+{
+	DBG("driver: %p name: %s", driver, driver->name);
+
+	g_drivers = g_slist_remove(g_drivers, driver);
+}
 
=== modified file 'src/voicecall.c'
--- src/voicecall.c	2016-01-15 16:03:09 +0000
+++ src/voicecall.c	2016-03-14 09:03:03 +0000
@@ -3463,9 +3463,11 @@
 	char number[OFONO_MAX_PHONE_NUMBER_LENGTH + 1];
 	struct ofono_error result;
 
-	/* Make sure we keep the system awake if we get woken up
-	 * shortly for processing the incoming request from the
-	 *  HFP HF. */
+	/*
+	 * If the device supports wakelocks, acquire one to
+	 * ensure the device is kept awake after being woken
+	 * by an incoming request from the HFP HF.
+	 */
 	wakelock_system_lock();
 
 	switch (ofono_emulator_request_get_type(req)) {
 
=== added file 'src/wakelock.c'
--- src/wakelock.c	1970-01-01 00:00:00 +0000
+++ src/wakelock.c	2016-03-14 09:03:03 +0000
@@ -0,0 +1,152 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2015 Jolla Ltd. All rights reserved.
+ *  Contact: Hannu Mallat <[e-mail]>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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 "log.h"
+#include "wakelock.h"
+#include "ofono.h"
+
+#define SYSTEM_WAKELOCK_NAME			"ofono-system"
+#define SYSTEM_WAKELOCK_DURATION		30
+
+static char *impl = NULL;
+static struct wakelock_table table;
+
+static struct wakelock *system_wakelock = NULL;
+static guint system_wakelock_source = 0;
+
+static gboolean system_wakelock_put(gpointer user_data)
+{
+	DBG("Releasing system wakelock");
+	wakelock_release(system_wakelock);
+	system_wakelock_source = 0;
+	return FALSE;
+}
+
+void wakelock_system_lock(void)
+{
+	guint old_source;
+
+	if (impl == NULL)
+		return;
+
+	DBG("Acquiring system wakelock");
+
+	old_source = system_wakelock_source;
+
+	system_wakelock_source = g_timeout_add_seconds(SYSTEM_WAKELOCK_DURATION,
+							system_wakelock_put,
+							NULL);
+
+	if (system_wakelock_source)
+		wakelock_acquire(system_wakelock);
+
+	if (old_source) {
+		g_source_remove(old_source);
+		wakelock_release(system_wakelock);
+	}
+}
+
+int wakelock_create(const char *name, struct wakelock **wakelock)
+{
+	if (impl == NULL) {
+		*wakelock = NULL;
+		return -EINVAL;
+	}
+
+	return (table.create)(name, wakelock);
+}
+
+int wakelock_free(struct wakelock *wakelock)
+{
+	if (impl == NULL)
+		return -EINVAL;
+
+	return table.free(wakelock);
+}
+
+int wakelock_acquire(struct wakelock *wakelock)
+{
+	if (impl == NULL)
+		return -EINVAL;
+
+	return table.acquire(wakelock);
+}
+
+int wakelock_release(struct wakelock *wakelock)
+{
+	if (impl == NULL)
+		return -EINVAL;
+
+	return table.release(wakelock);
+}
+
+ofono_bool_t wakelock_is_locked(struct wakelock *wakelock) {
+	if (impl == NULL)
+		return -EINVAL;
+
+	return table.is_locked(wakelock);
+}
+
+int wakelock_plugin_register(const char *name, struct wakelock_table *fns)
+{
+	if (impl)
+		return -EALREADY;
+
+	impl = g_strdup(name);
+	memcpy(&table, fns, sizeof(struct wakelock_table));
+	return 0;
+}
+
+int wakelock_plugin_unregister(void)
+{
+	if (impl == NULL)
+		return -ENOENT;
+
+	memset(&table, 0, sizeof(struct wakelock_table));
+	g_free(impl);
+	impl = NULL;
+
+	return 0;
+}
+
+int __ofono_wakelock_init(void)
+{
+	if (wakelock_create(SYSTEM_WAKELOCK_NAME, &system_wakelock) < 0)
+		ofono_warn("Failed to create system keep alive wakelock");
+
+	return 0;
+}
+
+void __ofono_wakelock_cleanup(void)
+{
+	if (system_wakelock)
+		wakelock_free(system_wakelock);
+}
 
=== removed file 'src/wakelock.c'
--- src/wakelock.c	2016-01-15 16:03:09 +0000
+++ src/wakelock.c	1970-01-01 00:00:00 +0000
@@ -1,151 +0,0 @@
-/*
- *
- *  oFono - Open Source Telephony
- *
- *  Copyright (C) 2015 Jolla Ltd. All rights reserved.
- *  Contact: Hannu Mallat <[e-mail]>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  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 "log.h"
-#include "wakelock.h"
-#include "ofono.h"
-
-#define SYSTEM_WAKELOCK_NAME			"ofono-system"
-#define SYSTEM_WAKELOCK_DURATION		30
-
-static char *impl = NULL;
-static struct wakelock_table table;
-
-static struct wakelock *system_wakelock = NULL;
-static guint system_wakelock_source = 0;
-
-static gboolean system_wakelock_put(gpointer user_data)
-{
-	DBG("Releasing system wakelock");
-	wakelock_release(system_wakelock);
-	system_wakelock_source = 0;
-	return FALSE;
-}
-
-void wakelock_system_lock(void)
-{
-	guint old_source;
-
-	if (!impl)
-		return;
-
-	DBG("Acquiring system wakelock");
-
-	old_source = system_wakelock_source;
-
-	system_wakelock_source = g_timeout_add_seconds(SYSTEM_WAKELOCK_DURATION,
-												system_wakelock_put,
-												NULL);
-	if (system_wakelock_source)
-		wakelock_acquire(system_wakelock);
-
-	if (old_source) {
-		g_source_remove(old_source);
-		wakelock_release(system_wakelock);
-	}
-}
-
-int wakelock_create(const char *name, struct wakelock **wakelock)
-{
-	if (!impl) {
-		*wakelock = NULL;
-		return -EINVAL;
-	}
-
-	return (table.create)(name, wakelock);
-}
-
-int wakelock_free(struct wakelock *wakelock)
-{
-	if (!impl)
-		return -EINVAL;
-
-	return table.free(wakelock);
-}
-
-int wakelock_acquire(struct wakelock *wakelock)
-{
-	if (!impl)
-		return -EINVAL;
-
-	return table.acquire(wakelock);
-}
-
-int wakelock_release(struct wakelock *wakelock)
-{
-	if (!impl)
-		return -EINVAL;
-
-	return table.release(wakelock);
-}
-
-ofono_bool_t wakelock_is_locked(struct wakelock *wakelock) {
-	if (!impl)
-		return -EINVAL;
-
-	return table.is_locked(wakelock);
-}
-
-int wakelock_plugin_register(const char *name, struct wakelock_table *fns)
-{
-	if (impl)
-		return -EALREADY;
-
-	impl = g_strdup(name);
-	memcpy(&table, fns, sizeof(struct wakelock_table));
-	return 0;
-}
-
-int wakelock_plugin_unregister(void)
-{
-	if (!impl)
-		return -ENOENT;
-
-	memset(&table, 0, sizeof(struct wakelock_table));
-	g_free(impl);
-	impl = NULL;
-
-	return 0;
-}
-
-int __ofono_wakelock_init(void)
-{
-	if (wakelock_create(SYSTEM_WAKELOCK_NAME, &system_wakelock) < 0)
-		ofono_warn("Failed to create system keep alive wakelock");
-
-	return 0;
-}
-
-void __ofono_wakelock_cleanup(void)
-{
-	if (system_wakelock)
-		wakelock_free(system_wakelock);
-}
 
=== added file 'unit/rilmodem-test-server.c'
--- unit/rilmodem-test-server.c	1970-01-01 00:00:00 +0000
+++ unit/rilmodem-test-server.c	2016-03-14 09:03:03 +0000
@@ -0,0 +1,237 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  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
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include <ofono/types.h>
+
+#include <gril.h>
+
+#include "rilmodem-test-server.h"
+
+#define MAX_REQUEST_SIZE 4096
+#define RIL_SERVER_SOCK_PATH    "/tmp/unittestril"
+
+struct server_data {
+	int server_sk;
+	ConnectFunc connect_func;
+	GIOChannel *server_io;
+	char *sock_name;
+	const struct rilmodem_test_data *rtd;
+	void *user_data;
+};
+
+/* Warning: length is stored in network order */
+struct rsp_hdr {
+	uint32_t length;
+	uint32_t unsolicited;
+	uint32_t serial;
+	uint32_t error;
+};
+
+static gboolean read_server(gpointer data)
+{
+	struct server_data *sd = data;
+	GIOStatus status;
+	gsize offset, rbytes, wbytes;
+	gchar *buf, *bufp;
+	uint32_t req_serial;
+	struct rsp_hdr rsp;
+
+	buf = g_malloc0(MAX_REQUEST_SIZE);
+
+	status = g_io_channel_read_chars(sd->server_io, buf, MAX_REQUEST_SIZE,
+								&rbytes, NULL);
+	g_assert(status == G_IO_STATUS_NORMAL);
+	g_assert(rbytes == sd->rtd->req_size);
+
+	/* validate len, and request_id */
+	g_assert(!memcmp(buf, sd->rtd->req_data, (sizeof(uint32_t) * 2)));
+
+	/*
+	 * header: size (uint32), reqid (uin32), serial (uint32)
+	 * header size == 16 ( excludes sizeof(size) )
+	 */
+
+	/* advance past request_no */
+	bufp = buf + (sizeof(uint32_t) * 2);
+
+	req_serial = (uint32_t) *bufp;
+
+	/* advance past serial_no */
+	bufp += sizeof(uint32_t);
+
+	/* validate the rest of the parcel... */
+	offset = (sizeof(uint32_t) * 3);
+	g_assert(!memcmp(bufp, sd->rtd->req_data + offset,
+						sd->rtd->req_size - offset));
+
+	/* Length does not include the length field. Network order. */
+	rsp.length = htonl(sizeof(rsp) - sizeof(rsp.length) +
+							sd->rtd->rsp_size);
+	rsp.unsolicited = 0;
+	rsp.serial = req_serial;
+	rsp.error = sd->rtd->rsp_error;
+
+	/* copy header */
+	memcpy(buf, &rsp, sizeof(rsp));
+
+	if (sd->rtd->rsp_size) {
+		bufp = buf + sizeof(rsp);
+
+		memcpy(bufp, sd->rtd->rsp_data, sd->rtd->rsp_size);
+	}
+
+	status = g_io_channel_write_chars(sd->server_io,
+					buf,
+					sizeof(rsp) + sd->rtd->rsp_size,
+					&wbytes, NULL);
+
+	/* FIXME: assert wbytes is correct */
+
+	g_assert(status == G_IO_STATUS_NORMAL);
+
+	g_free(buf);
+	g_io_channel_unref(sd->server_io);
+
+	return FALSE;
+}
+
+static gboolean on_socket_connected(GIOChannel *chan, GIOCondition cond,
+								gpointer data)
+{
+	struct server_data *sd = data;
+	struct sockaddr saddr;
+	unsigned int len = sizeof(saddr);
+	int fd;
+	GIOStatus status;
+
+	g_assert(cond == G_IO_IN);
+
+	fd = accept(sd->server_sk, &saddr, &len);
+	g_assert(fd != -1);
+
+	sd->server_io = g_io_channel_unix_new(fd);
+	g_assert(sd->server_io != NULL);
+
+	status = g_io_channel_set_encoding(sd->server_io, NULL, NULL);
+	g_assert(status == G_IO_STATUS_NORMAL);
+
+	g_io_channel_set_buffered(sd->server_io, FALSE);
+	g_io_channel_set_close_on_unref(sd->server_io, TRUE);
+
+	if (sd->connect_func)
+		sd->connect_func(sd->user_data);
+
+	if (sd->rtd->unsol_test == FALSE)
+		g_idle_add(read_server, sd);
+
+	return FALSE;
+}
+
+void rilmodem_test_server_close(struct server_data *sd)
+{
+	g_assert(sd->server_sk);
+	close(sd->server_sk);
+	remove(sd->sock_name);
+	g_free(sd->sock_name);
+	g_free(sd);
+}
+
+struct server_data *rilmodem_test_server_create(ConnectFunc connect,
+				const struct rilmodem_test_data *test_data,
+				void *data)
+{
+	GIOChannel *io;
+	struct sockaddr_un addr;
+	int retval;
+	struct server_data *sd;
+
+	sd = g_new0(struct server_data, 1);
+
+	sd->connect_func = connect;
+	sd->user_data = data;
+	sd->rtd = test_data;
+
+	sd->server_sk = socket(AF_UNIX, SOCK_STREAM, 0);
+	g_assert(sd->server_sk);
+
+	sd->sock_name =
+		g_strdup_printf(RIL_SERVER_SOCK_PATH"%u", (unsigned) getpid());
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sun_family = AF_UNIX;
+	strncpy(addr.sun_path, sd->sock_name, sizeof(addr.sun_path) - 1);
+
+	/* Unlink any existing socket for this session */
+	unlink(addr.sun_path);
+
+	retval = bind(sd->server_sk, (struct sockaddr *) &addr, sizeof(addr));
+	g_assert(retval >= 0);
+
+	retval = listen(sd->server_sk, 0);
+	g_assert(retval >= 0);
+
+	io = g_io_channel_unix_new(sd->server_sk);
+	g_assert(io != NULL);
+
+	g_io_channel_set_close_on_unref(io, TRUE);
+	g_io_add_watch_full(io,	G_PRIORITY_DEFAULT,
+				G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+				on_socket_connected, sd, NULL);
+
+	g_io_channel_unref(io);
+
+	return sd;
+}
+
+void rilmodem_test_server_write(struct server_data *sd,
+						const unsigned char *buf,
+						const size_t buf_len)
+{
+	GIOStatus status;
+	gsize wbytes;
+
+	status = g_io_channel_write_chars(sd->server_io,
+					(const char *) buf,
+					buf_len,
+					&wbytes, NULL);
+
+	g_assert(status == G_IO_STATUS_NORMAL);
+
+	status = g_io_channel_flush(sd->server_io, NULL);
+
+	g_assert(status == G_IO_STATUS_NORMAL);
+}
+
+const char *rilmodem_test_get_socket_name(struct server_data *sd)
+{
+	return sd->sock_name;
+}
 
=== added file 'unit/rilmodem-test-server.h'
--- unit/rilmodem-test-server.h	1970-01-01 00:00:00 +0000
+++ unit/rilmodem-test-server.h	2016-03-14 09:03:03 +0000
@@ -0,0 +1,47 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  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
+ *
+ */
+
+struct server_data;
+
+struct rilmodem_test_data {
+	const unsigned char *req_data;
+
+	const size_t req_size;
+
+	uint32_t rsp_error;
+	const unsigned char *rsp_data;
+	const size_t rsp_size;
+	gboolean unsol_test;
+};
+
+typedef void (*ConnectFunc)(void *data);
+
+void rilmodem_test_server_close(struct server_data *sd);
+
+struct server_data *rilmodem_test_server_create(ConnectFunc connect,
+				const struct rilmodem_test_data *test_data,
+				void *data);
+
+void rilmodem_test_server_write(struct server_data *sd,
+						const unsigned char *buf,
+						const size_t buf_len);
+
+const char *rilmodem_test_get_socket_name(struct server_data *sd);
 
=== modified file 'unit/test-grilreply.c'
--- unit/test-grilreply.c	2015-10-07 07:14:11 +0000
+++ unit/test-grilreply.c	2016-03-14 09:03:03 +0000
@@ -1420,7 +1420,7 @@
  * RIL_REQUEST_SET_FACILITY_LOCK reply with no parameters.
  */
 static const struct set_facility_lock_test reply_set_facility_lock_valid_1 = {
-	.retries = -1,
+	.retries = 0,
 	.msg = {
 		.buf = NULL,
 		.buf_len = 0,
@@ -1686,7 +1686,7 @@
 
 	reason = g_ril_reply_parse_call_fail_cause(NULL, data);
 
-	g_assert(reason >= 0);
+	g_assert(reason == OFONO_DISCONNECT_REASON_REMOTE_HANGUP);
 }
 
 static void test_reply_get_mute_off(gconstpointer data)
 
=== modified file 'unit/test-grilunsol.c'
--- unit/test-grilunsol.c	2014-08-19 16:29:51 +0000
+++ unit/test-grilunsol.c	2016-03-14 09:03:03 +0000
@@ -525,6 +525,115 @@
 	.error = 0,
 };
 
+/*
+ * The following hexadecimal data represents a serialized Binder parcel
+ * instance containing a valid RIL_UNSOL_RIL_CONNECTED message with the
+ * following parameters:
+ *
+ * [1, 10]
+ */
+static const guchar unsol_on_ril_connected_valid_parcel1[] = {
+	0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00
+};
+
+static const struct ril_msg unsol_on_ril_connected_valid_1 = {
+	.buf = (gchar *) &unsol_on_ril_connected_valid_parcel1,
+	.buf_len = sizeof(unsol_on_ril_connected_valid_parcel1),
+	.unsolicited = TRUE,
+	.req = RIL_UNSOL_RIL_CONNECTED,
+	.serial_no = 0,
+	.error = 0,
+};
+
+/*
+ * The following hexadecimal data represents a serialized Binder parcel
+ * instance containing a valid RIL_UNSOL_RIL_CONNECTED message with the
+ * following parameters:
+ *
+ * [2, 10, 11]
+ */
+static const guchar unsol_on_ril_connected_valid_parcel2[] = {
+	0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00
+};
+
+static const struct ril_msg unsol_on_ril_connected_valid_2 = {
+	.buf = (gchar *) &unsol_on_ril_connected_valid_parcel2,
+	.buf_len = sizeof(unsol_on_ril_connected_valid_parcel2),
+	.unsolicited = TRUE,
+	.req = RIL_UNSOL_RIL_CONNECTED,
+	.serial_no = 0,
+	.error = 0,
+};
+
+/*
+ * The following hexadecimal data represents a serialized Binder parcel
+ * instance containing a valid RIL_UNSOL_RIL_CONNECTED message with the
+ * following parameters:
+ *
+ * [1, 10, 11]
+ */
+static const guchar unsol_on_ril_connected_valid_parcel3[] = {
+	0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00
+};
+
+static const struct ril_msg unsol_on_ril_connected_valid_3 = {
+	.buf = (gchar *) &unsol_on_ril_connected_valid_parcel3,
+	.buf_len = sizeof(unsol_on_ril_connected_valid_parcel3),
+	.unsolicited = TRUE,
+	.req = RIL_UNSOL_RIL_CONNECTED,
+	.serial_no = 0,
+	.error = 0,
+};
+
+static const struct ril_msg unsol_on_ril_connected_invalid_1 = {
+	.buf = "",
+	.buf_len = 0,
+	.unsolicited = TRUE,
+	.req = RIL_UNSOL_RIL_CONNECTED,
+	.serial_no = 0,
+	.error = 0,
+};
+
+/*
+ * The following hexadecimal data represents a serialized Binder parcel
+ * instance containing an invalid RIL_UNSOL_RIL_CONNECTED message with the
+ * following parameters:
+ *
+ * [0]
+ */
+static const guchar unsol_on_ril_connected_invalid_parcel2[] = {
+	0x00, 0x00, 0x00, 0x00
+};
+
+static const struct ril_msg unsol_on_ril_connected_invalid_2 = {
+	.buf = (gchar *) &unsol_on_ril_connected_invalid_parcel2,
+	.buf_len = sizeof(unsol_on_ril_connected_invalid_parcel2),
+	.unsolicited = TRUE,
+	.req = RIL_UNSOL_RIL_CONNECTED,
+	.serial_no = 0,
+	.error = 0,
+};
+
+/*
+ * The following hexadecimal data represents a serialized Binder parcel
+ * instance containing an invalid RIL_UNSOL_RIL_CONNECTED message with the
+ * following parameters:
+ *
+ * [1]
+ */
+static const guchar unsol_on_ril_connected_invalid_parcel3[] = {
+	0x01, 0x00, 0x00, 0x00
+};
+
+static const struct ril_msg unsol_on_ril_connected_invalid_3 = {
+	.buf = (gchar *) &unsol_on_ril_connected_invalid_parcel3,
+	.buf_len = sizeof(unsol_on_ril_connected_invalid_parcel3),
+	.unsolicited = TRUE,
+	.req = RIL_UNSOL_RIL_CONNECTED,
+	.serial_no = 0,
+	.error = 0,
+};
+
 static void test_reply_data_call_invalid(gconstpointer data)
 {
 	struct ril_data_call_list *call_list;
@@ -599,6 +708,24 @@
 	g_assert(unsol != NULL);
 	g_ril_unsol_free_ussd(unsol);
 }
+
+static void test_unsol_on_ril_connected_valid(gconstpointer data)
+{
+	int version;
+
+	version = g_ril_unsol_parse_connected(NULL, (struct ril_msg *) data);
+
+	g_assert(version == 10);
+}
+
+static void test_unsol_on_ril_connected_invalid(gconstpointer data)
+{
+	int version;
+
+	version = g_ril_unsol_parse_connected(NULL, (struct ril_msg *) data);
+
+	g_assert(version == RIL_VERSION_UNSPECIFIED);
+}
 #endif
 
 int main(int argc, char **argv)
@@ -693,6 +820,36 @@
 				&unsol_on_ussd_valid_1,
 				test_unsol_on_ussd_valid);
 
+	g_test_add_data_func("/testgrilunsol/ril-connected: "
+				"valid RIL_CONNECTED Test 1",
+				&unsol_on_ril_connected_valid_1,
+				test_unsol_on_ril_connected_valid);
+
+	g_test_add_data_func("/testgrilunsol/ril-connected: "
+				"valid RIL_CONNECTED Test 2",
+				&unsol_on_ril_connected_valid_2,
+				test_unsol_on_ril_connected_valid);
+
+	g_test_add_data_func("/testgrilunsol/ril-connected: "
+				"valid RIL_CONNECTED Test 3",
+				&unsol_on_ril_connected_valid_3,
+				test_unsol_on_ril_connected_valid);
+
+	g_test_add_data_func("/testgrilunsol/ril-connected: "
+				"invalid RIL_CONNECTED Test 1",
+				&unsol_on_ril_connected_invalid_1,
+				test_unsol_on_ril_connected_invalid);
+
+	g_test_add_data_func("/testgrilunsol/ril-connected: "
+				"invalid RIL_CONNECTED Test 2",
+				&unsol_on_ril_connected_invalid_2,
+				test_unsol_on_ril_connected_invalid);
+
+	g_test_add_data_func("/testgrilunsol/ril-connected: "
+				"invalid RIL_CONNECTED Test 3",
+				&unsol_on_ril_connected_invalid_3,
+				test_unsol_on_ril_connected_invalid);
+
 #endif
 	return g_test_run();
 }
 
=== added file 'unit/test-rilmodem-cb.c'
--- unit/test-rilmodem-cb.c	1970-01-01 00:00:00 +0000
+++ unit/test-rilmodem-cb.c	2016-03-14 09:03:03 +0000
@@ -0,0 +1,605 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  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
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <errno.h>
+#include <glib.h>
+#include <stdio.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include <ofono/modem.h>
+#include <ofono/types.h>
+#include <ofono/call-barring.h>
+#include <gril.h>
+
+#include "common.h"
+#include "ril_constants.h"
+#include "rilmodem-test-server.h"
+
+static GMainLoop *mainloop;
+
+static const struct ofono_call_barring_driver *cbdriver;
+
+struct rilmodem_cb_data {
+	GRil *ril;
+	struct ofono_modem *modem;
+	gconstpointer test_data;
+	struct ofono_call_barring *cb;
+	struct server_data *serverd;
+};
+
+typedef gboolean (*StartFunc)(gpointer data);
+
+struct cb_data {
+	StartFunc start_func;
+
+	const char *lock;
+	int enable;
+	const char *passwd;
+	const char *new_passwd;
+	int cls;
+
+	struct rilmodem_test_data rtd;
+	enum ofono_error_type error_type;
+
+	int status;
+};
+
+static void query_callback(const struct ofono_error *error, int status,
+								gpointer data)
+{
+	struct rilmodem_cb_data *rsd = data;
+	const struct cb_data *cbd = rsd->test_data;
+
+	g_assert(error->type == cbd->error_type);
+
+	if (error->type == OFONO_ERROR_TYPE_NO_ERROR)
+		g_assert(status == cbd->status);
+
+	g_main_loop_quit(mainloop);
+}
+
+static gboolean trigger_query(gpointer data)
+{
+	struct rilmodem_cb_data *rsd = data;
+	const struct cb_data *cbd = rsd->test_data;
+
+	g_assert(cbdriver->query != NULL);
+	cbdriver->query(rsd->cb, cbd->lock, cbd->cls, query_callback, rsd);
+
+	return FALSE;
+}
+
+static void set_callback(const struct ofono_error *error, gpointer data)
+{
+	struct rilmodem_cb_data *rsd = data;
+	const struct cb_data *cbd = rsd->test_data;
+
+	g_assert(error->type == cbd->error_type);
+
+	g_main_loop_quit(mainloop);
+}
+
+static gboolean trigger_set(gpointer data)
+{
+	struct rilmodem_cb_data *rsd = data;
+	const struct cb_data *cbd = rsd->test_data;
+
+	g_assert(cbdriver->set != NULL);
+	cbdriver->set(rsd->cb, cbd->lock, cbd->enable, cbd->passwd, cbd->cls,
+							set_callback, rsd);
+
+	return FALSE;
+}
+
+static void set_passwd_callback(const struct ofono_error *error, gpointer data)
+{
+	struct rilmodem_cb_data *rsd = data;
+	const struct cb_data *cbd = rsd->test_data;
+
+	g_assert(error->type == cbd->error_type);
+
+	g_main_loop_quit(mainloop);
+}
+
+static gboolean trigger_set_passwd(gpointer data)
+{
+	struct rilmodem_cb_data *rsd = data;
+	const struct cb_data *cbd = rsd->test_data;
+
+	g_assert(cbdriver->set_passwd != NULL);
+	cbdriver->set_passwd(rsd->cb, cbd->lock, cbd->passwd, cbd->new_passwd,
+						set_passwd_callback, rsd);
+
+	return FALSE;
+}
+
+/* RIL_REQUEST_GET_FACILITY_LOCK witht the following parameters:
+ *
+ * facility="OI" (outgoing international calls)
+ * service class=1 ( VOICE )
+ */
+static const guchar req_get_facility_lock_parcel_1[] = {
+	0x00, 0x00, 0x00, 0x2c, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x49, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff
+};
+
+/*
+ * The following structure contains test data for a valid
+ * RIL_REQUEST_GET_FACILITY_LOCK reply with parameter {1}
+ * which indicates that call-barring is activated for the
+ * previously specified facility for the VOICE class.
+ */
+static const guchar reply_get_facility_lock_data_valid_1[] = {
+	0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
+};
+
+static const struct cb_data testdata_query_valid_1 = {
+	.start_func = trigger_query,
+	.lock = "OI",
+	.cls = BEARER_CLASS_VOICE,
+	.rtd = {
+		.req_data = req_get_facility_lock_parcel_1,
+		.req_size = sizeof(req_get_facility_lock_parcel_1),
+		.rsp_data = reply_get_facility_lock_data_valid_1,
+		.rsp_size = sizeof(reply_get_facility_lock_data_valid_1),
+	},
+	.status = BEARER_CLASS_VOICE,
+};
+
+/* GENERIC_FAILURE returned in RIL reply */
+static const struct cb_data testdata_query_invalid_1 = {
+	.start_func = trigger_query,
+	.lock = "OI",
+	.cls = BEARER_CLASS_VOICE,
+	.rtd = {
+		.req_data = req_get_facility_lock_parcel_1,
+		.req_size = sizeof(req_get_facility_lock_parcel_1),
+		.rsp_data = reply_get_facility_lock_data_valid_1,
+		.rsp_size = sizeof(reply_get_facility_lock_data_valid_1),
+		.rsp_error = RIL_E_GENERIC_FAILURE,
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/*
+ * The following structure contains test data for a valid
+ * RIL_REQUEST_GET_FACILITY_LOCK reply with invalid number
+ * of parameters {0} specified.
+ */
+static const guchar reply_get_facility_lock_data_invalid_2[] = {
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
+};
+
+static const struct cb_data testdata_query_invalid_2 = {
+	.start_func = trigger_query,
+	.lock = "OI",
+	.cls = BEARER_CLASS_VOICE,
+	.rtd = {
+		.req_data = req_get_facility_lock_parcel_1,
+		.req_size = sizeof(req_get_facility_lock_parcel_1),
+		.rsp_data = reply_get_facility_lock_data_invalid_2,
+		.rsp_size = sizeof(reply_get_facility_lock_data_invalid_2),
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/*
+ * The following structure contains test data for an invalid
+ * RIL_REQUEST_GET_FACILITY_LOCK reply with an invalid class
+ * mask (-255).
+ */
+static const guchar reply_get_facility_lock_data_invalid_3[] = {
+	0x01, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff
+};
+
+static const struct cb_data testdata_query_invalid_3 = {
+	.start_func = trigger_query,
+	.lock = "OI",
+	.cls = BEARER_CLASS_VOICE,
+	.rtd = {
+		.req_data = req_get_facility_lock_parcel_1,
+		.req_size = sizeof(req_get_facility_lock_parcel_1),
+		.rsp_data = reply_get_facility_lock_data_invalid_3,
+		.rsp_size = sizeof(reply_get_facility_lock_data_invalid_3),
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/*
+ * The following structure contains test data for a
+ * RIL_REQUEST_GET_FACILITY_LOCK reply with an incomplete
+ * integer parameter, which will trigger a malformed parcel
+ * error.
+ */
+static const guchar reply_get_facility_lock_data_invalid_4[] = {
+	0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00
+};
+
+static const struct cb_data testdata_query_invalid_4 = {
+	.start_func = trigger_query,
+	.lock = "OI",
+	.cls = BEARER_CLASS_VOICE,
+	.rtd = {
+		.req_data = req_get_facility_lock_parcel_1,
+		.req_size = sizeof(req_get_facility_lock_parcel_1),
+		.rsp_data = reply_get_facility_lock_data_invalid_4,
+		.rsp_size = sizeof(reply_get_facility_lock_data_invalid_4),
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/* RIL_REQUEST_SET_FACILITY_LOCK witht the following parameters:
+ *
+ * facility="OI" (outgoing international calls)
+ * unlock (0)
+ * passwd="0000"
+ * service class=1 ( VOICE )
+ */
+static const guchar req_set_facility_lock_parcel_1[] = {
+	0x00, 0x00, 0x00, 0x3c, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x49, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
+	0x04, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
+	0xff, 0xff, 0xff, 0xff
+};
+
+/*
+ * This test doesn't specify any data for RIL_REQUEST_SET_FACILITY_LOCK reply
+ * to simulate a reply generated by mako.
+ */
+static const struct cb_data testdata_set_valid_1 = {
+	.start_func = trigger_set,
+	.lock = "OI",
+	.passwd = "0000",
+	.cls = BEARER_CLASS_VOICE,
+	.rtd = {
+		.req_data = req_set_facility_lock_parcel_1,
+		.req_size = sizeof(req_set_facility_lock_parcel_1),
+	},
+};
+
+/* RIL_REQUEST_SET_FACILITY_LOCK witht the following parameters:
+ *
+ * facility="OI" (outgoing international calls)
+ * unlock (1)
+ * passwd="0000"
+ * service class=0 ( NONE )
+ */
+static const guchar req_set_facility_lock_parcel_2[] = {
+	0x00, 0x00, 0x00, 0x3c, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x49, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
+	0x04, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
+	0xff, 0xff, 0xff, 0xff
+};
+
+/*
+ * The following structure contains test data for a valid
+ * RIL_REQUEST_SET_FACILITY_LOCK reply with parameter {1}
+ */
+static const guchar reply_set_facility_lock_data_valid_2[] = {
+	0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
+};
+
+static const struct cb_data testdata_set_valid_2 = {
+	.start_func = trigger_set,
+	.lock = "OI",
+	.enable = 1,
+	.passwd = "0000",
+	.cls = BEARER_CLASS_DEFAULT,  /* updated to NONE in outgoing parcel */
+	.rtd = {
+		.req_data = req_set_facility_lock_parcel_2,
+		.req_size = sizeof(req_set_facility_lock_parcel_2),
+		.rsp_data = reply_set_facility_lock_data_valid_2,
+		.rsp_size = sizeof(reply_set_facility_lock_data_valid_2),
+	},
+};
+
+/* GENERIC_FAILURE returned in RIL reply */
+static const struct cb_data testdata_set_invalid_1 = {
+	.start_func = trigger_set,
+	.lock = "OI",
+	.enable = 1,
+	.passwd = "0000",
+	.cls = BEARER_CLASS_DEFAULT,
+	.rtd = {
+		.req_data = req_set_facility_lock_parcel_2,
+		.req_size = sizeof(req_set_facility_lock_parcel_2),
+		.rsp_error = RIL_E_GENERIC_FAILURE,
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+
+/*
+ * The following structure contains test data for a
+ * RIL_REQUEST_SET_FACILITY_LOCK reply with an invalid
+ * number of parameters {2}
+ */
+static const guchar reply_set_facility_lock_data_invalid_2[] = {
+	0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
+};
+
+static const struct cb_data testdata_set_invalid_2 = {
+	.start_func = trigger_set,
+	.lock = "OI",
+	.enable = 1,
+	.passwd = "0000",
+	.cls = BEARER_CLASS_DEFAULT,
+	.rtd = {
+		.req_data = req_set_facility_lock_parcel_2,
+		.req_size = sizeof(req_set_facility_lock_parcel_2),
+		.rsp_data = reply_set_facility_lock_data_invalid_2,
+		.rsp_size = sizeof(reply_set_facility_lock_data_invalid_2),
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/*
+ * The following structure contains test data for a
+ * RIL_REQUEST_SET_FACILITY_LOCK reply with an incomplete
+ * integer parameter, which will trigger a malformed parcel
+ * error.
+ */
+static const guchar reply_set_facility_lock_data_invalid_3[] = {
+	0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00
+};
+
+static const struct cb_data testdata_set_invalid_3 = {
+	.start_func = trigger_set,
+	.lock = "OI",
+	.enable = 1,
+	.passwd = "0000",
+	.cls = BEARER_CLASS_DEFAULT,
+	.rtd = {
+		.req_data = req_set_facility_lock_parcel_2,
+		.req_size = sizeof(req_set_facility_lock_parcel_2),
+		.rsp_data = reply_set_facility_lock_data_invalid_3,
+		.rsp_size = sizeof(reply_set_facility_lock_data_invalid_3),
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/* RIL_REQUEST_CHANGE_BARRING_PASSWORD with the following parameters:
+ *
+ * facility="OI" (outgoing international calls)
+ * old passwd="1111"
+ * new_passwd="0000"
+ */
+static const guchar req_change_barring_passwd_parcel_1[] = {
+	0x00, 0x00, 0x00, 0x38, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x49, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x31, 0x00, 0x31, 0x00,
+	0x31, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+	0x30, 0x00, 0x30, 0x00,	0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/*
+ * This test doesn't specify any data for RIL_REQUEST_SET_FACILITY_LOCK reply
+ * to simulate a reply generated by mako.
+ */
+static const struct cb_data testdata_set_passwd_valid_1 = {
+	.start_func = trigger_set_passwd,
+	.lock = "OI",
+	.passwd = "1111",
+	.new_passwd = "0000",
+	.rtd = {
+		.req_data = req_change_barring_passwd_parcel_1,
+		.req_size = sizeof(req_change_barring_passwd_parcel_1),
+	},
+};
+
+/* GENERIC_FAILURE returned in RIL reply */
+static const struct cb_data testdata_set_passwd_invalid_1 = {
+	.start_func = trigger_set_passwd,
+	.lock = "OI",
+	.passwd = "1111",
+	.new_passwd = "0000",
+	.rtd = {
+		.req_data = req_change_barring_passwd_parcel_1,
+		.req_size = sizeof(req_change_barring_passwd_parcel_1),
+		.rsp_error = RIL_E_GENERIC_FAILURE,
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/* Declarations && Re-implementations of core functions. */
+void ril_call_barring_exit(void);
+void ril_call_barring_init(void);
+
+struct ofono_call_barring {
+	void *driver_data;
+	const struct cb_data *cbd;
+};
+
+struct ofono_call_barring *ofono_call_barring_create(struct ofono_modem *modem,
+							unsigned int vendor,
+							const char *driver,
+							void *data)
+{
+	struct rilmodem_cb_data *rsd = data;
+	struct ofono_call_barring *cb = g_new0(struct ofono_call_barring, 1);
+	int retval;
+
+	retval = cbdriver->probe(cb, OFONO_RIL_VENDOR_AOSP, rsd->ril);
+	g_assert(retval == 0);
+
+	return cb;
+}
+
+int ofono_call_barring_driver_register(const struct ofono_call_barring_driver *d)
+{
+	if (cbdriver == NULL)
+		cbdriver = d;
+
+	return 0;
+}
+
+void ofono_call_barring_set_data(struct ofono_call_barring *cb, void *data)
+{
+	cb->driver_data = data;
+}
+
+void *ofono_call_barring_get_data(struct ofono_call_barring *cb)
+{
+	return cb->driver_data;
+}
+
+void ofono_call_barring_register(struct ofono_call_barring *cb)
+{
+}
+
+void ofono_call_barring_driver_unregister(const struct ofono_call_barring_driver *d)
+{
+}
+
+/*
+ * As all our architectures are little-endian except for
+ * PowerPC, and the Binder wire-format differs slightly
+ * depending on endian-ness, the following guards against test
+ * failures when run on PowerPC.
+ */
+#if BYTE_ORDER == LITTLE_ENDIAN
+
+static void server_connect_cb(gpointer data)
+{
+	struct rilmodem_cb_data *rsd = data;
+	const struct cb_data *cbd = rsd->test_data;
+
+	/* This causes local impl of _create() to call driver's probe func. */
+	rsd->cb = ofono_call_barring_create(NULL, OFONO_RIL_VENDOR_AOSP,
+							"rilmodem", rsd);
+	rsd->cb->cbd = cbd;
+
+	/* add_idle doesn't work, read blocks main loop!!! */
+
+	if (cbd->rtd.unsol_test)
+		g_idle_add(cbd->start_func, (void *) rsd);
+	else
+		g_assert(cbd->start_func(rsd) == FALSE);
+}
+
+/*
+ * This unit test:
+ *  - does some test data setup
+ *  - configures a dummy server socket
+ *  - creates a new gril client instance
+ *    - triggers a connect to the dummy
+ *      server socket
+ *  - starts a mainloop
+ */
+static void test_call_barring_func(gconstpointer data)
+{
+	const struct cb_data *sd = data;
+	struct rilmodem_cb_data *rsd;
+
+	ril_call_barring_init();
+
+	rsd = g_new0(struct rilmodem_cb_data, 1);
+
+	rsd->test_data = sd;
+
+	rsd->serverd = rilmodem_test_server_create(&server_connect_cb,
+								&sd->rtd, rsd);
+
+	rsd->ril = g_ril_new(rilmodem_test_get_socket_name(rsd->serverd),
+							OFONO_RIL_VENDOR_AOSP);
+	g_assert(rsd->ril != NULL);
+
+	mainloop = g_main_loop_new(NULL, FALSE);
+
+	g_main_loop_run(mainloop);
+	g_main_loop_unref(mainloop);
+
+	cbdriver->remove(rsd->cb);
+	g_ril_unref(rsd->ril);
+	g_free(rsd);
+
+	rilmodem_test_server_close(rsd->serverd);
+
+	ril_call_barring_exit();
+}
+
+#endif
+
+int main(int argc, char **argv)
+{
+	g_test_init(&argc, &argv, NULL);
+
+/*
+ * As all our architectures are little-endian except for
+ * PowerPC, and the Binder wire-format differs slightly
+ * depending on endian-ness, the following guards against test
+ * failures when run on PowerPC.
+ */
+#if BYTE_ORDER == LITTLE_ENDIAN
+	g_test_add_data_func("/testrilmodemcallbarring/query/valid/1",
+					&testdata_query_valid_1,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/query/invalid/1",
+					&testdata_query_invalid_1,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/query/invalid/2",
+					&testdata_query_invalid_2,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/query/invalid/3",
+					&testdata_query_invalid_3,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/query/invalid/4",
+					&testdata_query_invalid_3,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/set/valid/1",
+					&testdata_set_valid_1,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/set/valid/2",
+					&testdata_set_valid_2,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/set/invalid/1",
+					&testdata_set_invalid_1,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/set/invalid/2",
+					&testdata_set_invalid_2,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/set/invalid/3",
+					&testdata_set_invalid_3,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/set_passwd/valid/1",
+					&testdata_set_passwd_valid_1,
+					test_call_barring_func);
+	g_test_add_data_func("/testrilmodemcallbarring/set_passwd/invalid/1",
+					&testdata_set_passwd_invalid_1,
+					test_call_barring_func);
+#endif
+	return g_test_run();
+}
 
=== modified file 'unit/test-rilmodem-cs.c'
--- unit/test-rilmodem-cs.c	2015-11-05 21:28:06 +0000
+++ unit/test-rilmodem-cs.c	2016-03-14 09:03:03 +0000
@@ -40,29 +40,18 @@
 
 #include "common.h"
 #include "ril_constants.h"
-
-#define MAX_REQUEST_SIZE 4096
+#include "rilmodem-test-server.h"
 
 static GMainLoop *mainloop;
 
 static const struct ofono_call_settings_driver *csdriver;
 
-struct rilmodemcs_data {
+struct rilmodem_cs_data {
 	GRil *ril;
-	int sk;
-	gint server_watch;
-	GIOChannel *server_io;
 	struct ofono_modem *modem;
 	gconstpointer test_data;
 	struct ofono_call_settings *cs;
-};
-
-/* Warning: length is stored in network order */
-struct rsp_hdr {
-	uint32_t length;
-	uint32_t unsolicited;
-	uint32_t serial;
-	uint32_t error;
+	struct server_data *serverd;
 };
 
 typedef gboolean (*StartFunc)(gpointer data);
@@ -72,13 +61,7 @@
 	gint param_int1;
 	gint param_int2;
 
-	const guchar *parcel_data;
-
-	const gsize parcel_size;
-
-	uint32_t rsp_error;
-	const guchar *rsp_data;
-	const gsize rsp_size;
+	struct rilmodem_test_data rtd;
 	enum ofono_error_type error_type;
 	gint cb_int1;
 	gint cb_int2;
@@ -87,8 +70,8 @@
 static void status_query_callback(const struct ofono_error *error, int status,
 								 gpointer data)
 {
-	struct rilmodemcs_data *rcsd = data;
-	const struct cs_data *csd = rcsd->test_data;
+	struct rilmodem_cs_data *rcd = data;
+	const struct cs_data *csd = rcd->test_data;
 
 	g_assert(error->type == csd->error_type);
 
@@ -101,8 +84,8 @@
 static void clir_query_callback(const struct ofono_error *error, int override,
 						int network, gpointer data)
 {
-	struct rilmodemcs_data *rcsd = data;
-	const struct cs_data *csd = rcsd->test_data;
+	struct rilmodem_cs_data *rcd = data;
+	const struct cs_data *csd = rcd->test_data;
 
 	g_assert(error->type == csd->error_type);
 
@@ -116,8 +99,8 @@
 
 static void set_callback(const struct ofono_error *error, gpointer data)
 {
-	struct rilmodemcs_data *rcsd = data;
-	const struct cs_data *csd = rcsd->test_data;
+	struct rilmodem_cs_data *rcd = data;
+	const struct cs_data *csd = rcd->test_data;
 
 	g_assert(error->type == csd->error_type);
 
@@ -126,56 +109,56 @@
 
 static gboolean trigger_clip_query(gpointer data)
 {
-	struct rilmodemcs_data *rcsd = data;
+	struct rilmodem_cs_data *rcd = data;
 
 	g_assert(csdriver->clip_query != NULL);
-	csdriver->clip_query(rcsd->cs, status_query_callback, rcsd);
+	csdriver->clip_query(rcd->cs, status_query_callback, rcd);
 
 	return FALSE;
 }
 
 static gboolean trigger_cw_query(gpointer data)
 {
-	struct rilmodemcs_data *rcsd = data;
+	struct rilmodem_cs_data *rcd = data;
 
 	g_assert(csdriver->cw_query != NULL);
 
 	/* cls is explicitly ignored by rilmodem; just use 0 */
-	csdriver->cw_query(rcsd->cs, 0, status_query_callback, rcsd);
+	csdriver->cw_query(rcd->cs, 0, status_query_callback, rcd);
 
 	return FALSE;
 }
 
 static gboolean trigger_cw_set(gpointer data)
 {
-	struct rilmodemcs_data *rcsd = data;
-	const struct cs_data *csd = rcsd->test_data;
+	struct rilmodem_cs_data *rcd = data;
+	const struct cs_data *csd = rcd->test_data;
 
 	g_assert(csdriver->cw_set != NULL);
 
-	csdriver->cw_set(rcsd->cs, csd->param_int1, csd->param_int2,
-						set_callback, rcsd);
+	csdriver->cw_set(rcd->cs, csd->param_int1, csd->param_int2,
+						set_callback, rcd);
 
 	return FALSE;
 }
 
 static gboolean trigger_clir_query(gpointer data)
 {
-	struct rilmodemcs_data *rcsd = data;
+	struct rilmodem_cs_data *rcd = data;
 
 	g_assert(csdriver->clir_query != NULL);
-	csdriver->clir_query(rcsd->cs, clir_query_callback, rcsd);
+	csdriver->clir_query(rcd->cs, clir_query_callback, rcd);
 
 	return FALSE;
 }
 
 static gboolean trigger_clir_set(gpointer data)
 {
-	struct rilmodemcs_data *rcsd = data;
-	const struct cs_data *csd = rcsd->test_data;
+	struct rilmodem_cs_data *rcd = data;
+	const struct cs_data *csd = rcd->test_data;
 
 	g_assert(csdriver->clir_set != NULL);
-	csdriver->clir_set(rcsd->cs, csd->param_int1, set_callback, rcsd);
+	csdriver->clir_set(rcd->cs, csd->param_int1, set_callback, rcd);
 
 	return FALSE;
 }
@@ -192,11 +175,13 @@
 
 static const struct cs_data testdata_clip_query_valid_1 = {
 	.start_func = trigger_clip_query,
-	.parcel_data = req_clip_query_parcel_1,
-	.parcel_size = sizeof(req_clip_query_parcel_1),
-	.rsp_data = rsp_clip_query_data_1,
-	.rsp_size = sizeof(rsp_clip_query_data_1),
-	.rsp_error = RIL_E_SUCCESS,
+	.rtd = {
+		.req_data = req_clip_query_parcel_1,
+		.req_size = sizeof(req_clip_query_parcel_1),
+		.rsp_data = rsp_clip_query_data_1,
+		.rsp_size = sizeof(rsp_clip_query_data_1),
+		.rsp_error = RIL_E_SUCCESS,
+	},
 	.cb_int1 = 1,
 	.error_type = OFONO_ERROR_TYPE_NO_ERROR,
 };
@@ -209,21 +194,25 @@
 /* reply parse error causes status to be returned as -1 */
 static const struct cs_data testdata_clip_query_invalid_1 = {
 	.start_func = trigger_clip_query,
-	.parcel_data = req_clip_query_parcel_1,
-	.parcel_size = sizeof(req_clip_query_parcel_1),
-	.rsp_data = rsp_clip_query_data_2,
-	.rsp_size = sizeof(rsp_clip_query_data_2),
+	.rtd = {
+		.req_data = req_clip_query_parcel_1,
+		.req_size = sizeof(req_clip_query_parcel_1),
+		.rsp_data = rsp_clip_query_data_2,
+		.rsp_size = sizeof(rsp_clip_query_data_2),
+		.rsp_error = RIL_E_SUCCESS,
+	},
 	.cb_int1 = -1,
-	.rsp_error = RIL_E_SUCCESS,
 	.error_type = OFONO_ERROR_TYPE_NO_ERROR,
 };
 
 /* error triggered by RIL reply error */
 static const struct cs_data testdata_clip_query_invalid_2 = {
 	.start_func = trigger_clip_query,
-	.parcel_data = req_clip_query_parcel_1,
-	.parcel_size = sizeof(req_clip_query_parcel_1),
-	.rsp_error = RIL_E_GENERIC_FAILURE,
+	.rtd = {
+		.req_data = req_clip_query_parcel_1,
+		.req_size = sizeof(req_clip_query_parcel_1),
+		.rsp_error = RIL_E_GENERIC_FAILURE,
+	},
 	.error_type = OFONO_ERROR_TYPE_FAILURE,
 };
 
@@ -240,11 +229,13 @@
 
 static const struct cs_data testdata_cw_query_valid_1 = {
 	.start_func = trigger_cw_query,
-	.parcel_data = req_cw_query_parcel_1,
-	.parcel_size = sizeof(req_cw_query_parcel_1),
-	.rsp_data = rsp_cw_query_data_1,
-	.rsp_size = sizeof(rsp_cw_query_data_1),
-	.rsp_error = RIL_E_SUCCESS,
+	.rtd = {
+		.req_data = req_cw_query_parcel_1,
+		.req_size = sizeof(req_cw_query_parcel_1),
+		.rsp_data = rsp_cw_query_data_1,
+		.rsp_size = sizeof(rsp_cw_query_data_1),
+		.rsp_error = RIL_E_SUCCESS,
+	},
 	.cb_int1 = 3,
 	.error_type = OFONO_ERROR_TYPE_NO_ERROR,
 };
@@ -257,24 +248,28 @@
 /* reply parse error causes status to be returned as -1 */
 static const struct cs_data testdata_cw_query_invalid_1 = {
 	.start_func = trigger_cw_query,
-	.parcel_data = req_cw_query_parcel_1,
-	.parcel_size = sizeof(req_cw_query_parcel_1),
-	.rsp_data = rsp_cw_query_data_2,
-	.rsp_size = sizeof(rsp_cw_query_data_2),
+	.rtd = {
+		.req_data = req_cw_query_parcel_1,
+		.req_size = sizeof(req_cw_query_parcel_1),
+		.rsp_data = rsp_cw_query_data_2,
+		.rsp_size = sizeof(rsp_cw_query_data_2),
+		.rsp_error = RIL_E_SUCCESS,
+	},
 	.cb_int1 = -1,
-	.rsp_error = RIL_E_SUCCESS,
 	.error_type = OFONO_ERROR_TYPE_NO_ERROR,
 };
 
 /* GENERIC_FAILURE returned in RIL reply */
 static const struct cs_data testdata_cw_query_invalid_2 = {
 	.start_func = trigger_cw_query,
-	.parcel_data = req_cw_query_parcel_1,
-	.parcel_size = sizeof(req_cw_query_parcel_1),
-	.rsp_data = rsp_cw_query_data_2,
-	.rsp_size = sizeof(rsp_cw_query_data_2),
+	.rtd = {
+		.req_data = req_cw_query_parcel_1,
+		.req_size = sizeof(req_cw_query_parcel_1),
+		.rsp_data = rsp_cw_query_data_2,
+		.rsp_size = sizeof(rsp_cw_query_data_2),
+		.rsp_error = RIL_E_GENERIC_FAILURE,
+	},
 	.cb_int1 = -1,
-	.rsp_error = RIL_E_GENERIC_FAILURE,
 	.error_type = OFONO_ERROR_TYPE_FAILURE,
 };
 
@@ -289,9 +284,11 @@
 	.start_func = trigger_cw_set,
 	.param_int1 = 1,
 	.param_int2 = BEARER_CLASS_DEFAULT,
-	.parcel_data = req_cw_set_enabled_parcel_1,
-	.parcel_size = sizeof(req_cw_set_enabled_parcel_1),
-	.rsp_error = RIL_E_SUCCESS,
+	.rtd = {
+		.req_data = req_cw_set_enabled_parcel_1,
+		.req_size = sizeof(req_cw_set_enabled_parcel_1),
+		.rsp_error = RIL_E_SUCCESS,
+	},
 	.error_type = OFONO_ERROR_TYPE_NO_ERROR,
 };
 
@@ -306,9 +303,11 @@
 	.start_func = trigger_cw_set,
 	.param_int1 = 0,
 	.param_int2 = 0,
-	.parcel_data = req_cw_set_disabled_parcel_2,
-	.parcel_size = sizeof(req_cw_set_disabled_parcel_2),
-	.rsp_error = RIL_E_GENERIC_FAILURE,
+	.rtd = {
+		.req_data = req_cw_set_disabled_parcel_2,
+		.req_size = sizeof(req_cw_set_disabled_parcel_2),
+		.rsp_error = RIL_E_GENERIC_FAILURE,
+	},
 	.error_type = OFONO_ERROR_TYPE_FAILURE,
 };
 
@@ -324,13 +323,15 @@
 
 static const struct cs_data testdata_clir_query_valid_1 = {
 	.start_func = trigger_clir_query,
-	.parcel_data = req_clir_query_parcel_1,
-	.parcel_size = sizeof(req_clir_query_parcel_1),
-	.rsp_data = rsp_clir_query_data_1,
-	.rsp_size = sizeof(rsp_clir_query_data_1),
+	.rtd = {
+		.req_data = req_clir_query_parcel_1,
+		.req_size = sizeof(req_clir_query_parcel_1),
+		.rsp_data = rsp_clir_query_data_1,
+		.rsp_size = sizeof(rsp_clir_query_data_1),
+		.rsp_error = RIL_E_SUCCESS,
+	},
 	.cb_int1 = 2,
 	.cb_int2 = 4,
-	.rsp_error = RIL_E_SUCCESS,
 	.error_type = OFONO_ERROR_TYPE_NO_ERROR,
 };
 
@@ -340,11 +341,13 @@
 };
 static const struct cs_data testdata_clir_query_invalid_1 = {
 	.start_func = trigger_clir_query,
-	.parcel_data = req_clir_query_parcel_1,
-	.parcel_size = sizeof(req_clir_query_parcel_1),
-	.rsp_data = rsp_clir_query_data_2,
-	.rsp_size = sizeof(rsp_clir_query_data_2),
-	.rsp_error = RIL_E_SUCCESS,
+	.rtd = {
+		.req_data = req_clir_query_parcel_1,
+		.req_size = sizeof(req_clir_query_parcel_1),
+		.rsp_data = rsp_clir_query_data_2,
+		.rsp_size = sizeof(rsp_clir_query_data_2),
+		.rsp_error = RIL_E_SUCCESS,
+	},
 	.error_type = OFONO_ERROR_TYPE_FAILURE,
 };
 
@@ -357,9 +360,11 @@
 static const struct cs_data testdata_clir_set_valid_1 = {
 	.start_func = trigger_clir_set,
 	.param_int1 = OFONO_CLIR_OPTION_DEFAULT,
-	.parcel_data = req_clir_set_mode0_parcel_1,
-	.parcel_size = sizeof(req_clir_set_mode0_parcel_1),
-	.rsp_error = RIL_E_SUCCESS,
+	.rtd = {
+		.req_data = req_clir_set_mode0_parcel_1,
+		.req_size = sizeof(req_clir_set_mode0_parcel_1),
+		.rsp_error = RIL_E_SUCCESS,
+	},
 	.error_type = OFONO_ERROR_TYPE_NO_ERROR,
 };
 
@@ -373,9 +378,12 @@
 static const struct cs_data testdata_clir_set_invalid_1 = {
 	.start_func = trigger_clir_set,
 	.param_int1 = OFONO_CLIR_OPTION_INVOCATION,
-	.parcel_data = req_clir_set_mode0_parcel_2,
-	.parcel_size = sizeof(req_clir_set_mode0_parcel_2),
-	.rsp_error = RIL_E_GENERIC_FAILURE,
+
+	.rtd = {
+		.req_data = req_clir_set_mode0_parcel_2,
+		.req_size = sizeof(req_clir_set_mode0_parcel_2),
+		.rsp_error = RIL_E_GENERIC_FAILURE,
+	},
 	.error_type = OFONO_ERROR_TYPE_FAILURE,
 };
 
@@ -392,11 +400,11 @@
 							const char *driver,
 							void *data)
 {
-	struct rilmodemcs_data *rcsd = data;
+	struct rilmodem_cs_data *rcd = data;
 	struct ofono_call_settings *cs = g_new0(struct ofono_call_settings, 1);
 	int retval;
 
-	retval = csdriver->probe(cs, OFONO_RIL_VENDOR_AOSP, rcsd->ril);
+	retval = csdriver->probe(cs, OFONO_RIL_VENDOR_AOSP, rcd->ril);
 	g_assert(retval == 0);
 
 	return cs;
@@ -422,12 +430,10 @@
 
 void ofono_call_settings_register(struct ofono_call_settings *cs)
 {
-	;
 }
 
 void ofono_call_settings_driver_unregister(const struct ofono_call_settings_driver *d)
 {
-	;
 }
 
 /*
@@ -438,163 +444,23 @@
  */
 #if BYTE_ORDER == LITTLE_ENDIAN
 
-static gboolean read_server(gpointer data)
-{
-	GIOStatus status;
-	struct rilmodemcs_data *rcsd = data;
-	gsize offset, rbytes, wbytes;
-	gchar *buf, *bufp;
-	uint32_t req_serial;
-	struct rsp_hdr rsp;
-
-	/*
-	 * FIXME: separate out verification from here, so read_server doesn't
-	 * need to know about cs_data.
-	 */
-	const struct cs_data *csd = rcsd->test_data;
-
-	buf = g_malloc0(MAX_REQUEST_SIZE);
-
-	status = g_io_channel_read_chars(rcsd->server_io, buf, MAX_REQUEST_SIZE,
-								&rbytes, NULL);
-	g_assert(status == G_IO_STATUS_NORMAL);
-	g_assert(rbytes == csd->parcel_size);
-
-	/* validate len, and request_id */
-	g_assert(!memcmp(buf, csd->parcel_data, (sizeof(uint32_t) * 2)));
-
-	/*
-	 * header: size (uint32), reqid (uin32), serial (uint32)
-	 * header size == 16 ( excludes sizeof(size) )
-	 */
-
-	/* advance past request_no */
-	bufp = buf + (sizeof(uint32_t) * 2);
-
-	req_serial = (uint32_t) *bufp;
-
-	/* advance past serial_no */
-	bufp += sizeof(uint32_t);
-
-	/* validate the rest of the parcel... */
-	offset = (sizeof(uint32_t) * 3);
-	g_assert(!memcmp(bufp, csd->parcel_data + offset,
-						csd->parcel_size - offset));
-
-	/* Length does not include the length field. Network order. */
-	rsp.length = htonl(sizeof(rsp) - sizeof(rsp.length) + csd->rsp_size);
-	rsp.unsolicited = 0;
-	rsp.serial = req_serial;
-	rsp.error = csd->rsp_error;
-
-	/* copy header */
-	memcpy(buf, &rsp, sizeof(rsp));
-
-	if (csd->rsp_size) {
-		bufp = buf + sizeof(rsp);
-
-		memcpy(bufp, csd->rsp_data, csd->rsp_size);
-	}
-
-
-	status = g_io_channel_write_chars(rcsd->server_io,
-					buf,
-					sizeof(rsp) + csd->rsp_size,
-					&wbytes, NULL);
-
-	/* FIXME: assert wbytes is correct */
-
-	g_assert(status == G_IO_STATUS_NORMAL);
-
-	g_free(buf);
-	g_io_channel_unref(rcsd->server_io);
-
-	return FALSE;
-}
-
-static gboolean on_socket_connected(GIOChannel *chan, GIOCondition cond,
-								gpointer data)
-{
-	struct rilmodemcs_data *rcsd = data;
-	const struct cs_data *csd = rcsd->test_data;
-	struct sockaddr saddr;
-	unsigned int len = sizeof(saddr);
-	int fd;
-	GIOChannel *server_io = NULL;
-	GIOStatus status;
-
-	g_assert(cond == G_IO_IN);
-
-	fd = accept(rcsd->sk, &saddr, &len);
-	g_assert(fd != -1);
-
-	server_io = g_io_channel_unix_new(fd);
-	g_assert(server_io != NULL);
+static void server_connect_cb(gpointer data)
+{
+	struct rilmodem_cs_data *rcd = data;
+	const struct cs_data *csd = rcd->test_data;
 
 	/* This causes local impl of _create() to call driver's probe func. */
-	rcsd->cs = ofono_call_settings_create(NULL, OFONO_RIL_VENDOR_AOSP,
-							"rilmodem", rcsd);
+	rcd->cs = ofono_call_settings_create(NULL, OFONO_RIL_VENDOR_AOSP,
+							"rilmodem", rcd);
 
 	/* add_idle doesn't work, read blocks main loop!!! */
-	g_assert(csd->start_func(rcsd) == FALSE);
-
-	status = g_io_channel_set_encoding(server_io, NULL, NULL);
-	g_assert(status == G_IO_STATUS_NORMAL);
-
-	g_io_channel_set_buffered(server_io, FALSE);
-	g_io_channel_set_close_on_unref(server_io, TRUE);
-
-	rcsd->server_io = server_io;
-
-	g_idle_add(read_server, rcsd);
-
-	/* single-shot callback */
-	return FALSE;
-}
-
-static void create_server_socket(const char *sock_path,
-					struct rilmodemcs_data *rcsd)
-{
-	GIOChannel *io;
-	struct sockaddr_un addr;
-	int retval;
-
-	rcsd->sk = socket(AF_UNIX, SOCK_STREAM, 0);
-	g_assert(rcsd->sk);
-
-	memset(&addr, 0, sizeof(addr));
-	addr.sun_family = AF_UNIX;
-	strncpy(addr.sun_path, sock_path, sizeof(addr.sun_path) - 1);
-
-	/* Unlink any existing socket for this session */
-	unlink(addr.sun_path);
-
-	retval = bind(rcsd->sk, (struct sockaddr *) &addr, sizeof(addr));
-	g_assert(retval >= 0);
-
-	retval = listen(rcsd->sk, 0);
-	g_assert(retval >= 0);
-
-	io = g_io_channel_unix_new(rcsd->sk);
-	g_assert(io != NULL);
-
-	g_io_channel_set_close_on_unref(io, TRUE);
-	g_io_channel_set_flags(io, G_IO_FLAG_NONBLOCK, NULL);
-
-	rcsd->server_watch = g_io_add_watch_full(io,
-				G_PRIORITY_DEFAULT,
-				G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
-				on_socket_connected, rcsd, NULL);
-
-	g_io_channel_unref(io);
+	g_assert(csd->start_func(rcd) == FALSE);
 }
 
 /*
  * This unit test:
  *  - does some test data setup
  *  - configures a dummy server socket
- *    - on_socket_connected: callback for
- *      incoming socket connects
  *  - creates a new gril client instance
  *    - triggers a connect to the dummy
  *      server socket
@@ -603,27 +469,31 @@
 static void test_cs_func(gconstpointer data)
 {
 	const struct cs_data *csd = data;
-	struct rilmodemcs_data *rcsd;
+	struct rilmodem_cs_data *rcd;
 
 	ril_call_settings_init();
 
-	rcsd = g_new0(struct rilmodemcs_data, 1);
-
-	rcsd->test_data = csd;
-
-	create_server_socket("/tmp/unittestril", rcsd);
-
-	rcsd->ril = g_ril_new("/tmp/unittestril", OFONO_RIL_VENDOR_AOSP);
-	g_assert(rcsd->ril != NULL);
+	rcd = g_new0(struct rilmodem_cs_data, 1);
+
+	rcd->test_data = csd;
+
+	rcd->serverd = rilmodem_test_server_create(&server_connect_cb,
+								&csd->rtd, rcd);
+
+	rcd->ril = g_ril_new(rilmodem_test_get_socket_name(rcd->serverd),
+							OFONO_RIL_VENDOR_AOSP);
+	g_assert(rcd->ril != NULL);
 
 	mainloop = g_main_loop_new(NULL, FALSE);
 
 	g_main_loop_run(mainloop);
 	g_main_loop_unref(mainloop);
 
-	csdriver->remove(rcsd->cs);
-	g_ril_unref(rcsd->ril);
-	g_free(rcsd);
+	csdriver->remove(rcd->cs);
+	g_ril_unref(rcd->ril);
+	g_free(rcd);
+
+	rilmodem_test_server_close(rcd->serverd);
 
 	ril_call_settings_exit();
 }
 
=== added file 'unit/test-rilmodem-sms.c'
--- unit/test-rilmodem-sms.c	1970-01-01 00:00:00 +0000
+++ unit/test-rilmodem-sms.c	2016-03-14 09:03:03 +0000
@@ -0,0 +1,596 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  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
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <errno.h>
+#include <glib.h>
+#include <stdio.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include <ofono/modem.h>
+#include <ofono/types.h>
+#include <ofono/sms.h>
+#include <gril.h>
+
+#include "common.h"
+#include "ril_constants.h"
+#include "rilmodem-test-server.h"
+
+static GMainLoop *mainloop;
+
+static const struct ofono_sms_driver *smsdriver;
+
+struct rilmodem_sms_data {
+	GRil *ril;
+	struct ofono_modem *modem;
+	gconstpointer test_data;
+	struct ofono_sms *sms;
+	struct server_data *serverd;
+};
+
+typedef gboolean (*StartFunc)(gpointer data);
+
+struct sms_data {
+	StartFunc start_func;
+
+	const unsigned char *pdu;
+	gint pdu_len;
+	gint tpdu_len;
+	gint mms;
+
+	struct rilmodem_test_data rtd;
+	enum ofono_error_type error_type;
+
+	const struct ofono_phone_number ph;
+	gint mr;
+};
+
+static void sca_query_callback(const struct ofono_error *error,
+					const struct ofono_phone_number *ph,
+					gpointer data)
+{
+	struct rilmodem_sms_data *rsd = data;
+	const struct sms_data *sd = rsd->test_data;
+
+	g_assert(error->type == sd->error_type);
+
+	if (error->type == OFONO_ERROR_TYPE_NO_ERROR) {
+		g_assert(ph->type == sd->ph.type);
+		g_assert(strcmp(ph->number, sd->ph.number) == 0);
+	}
+
+	g_main_loop_quit(mainloop);
+}
+
+static void sca_set_callback(const struct ofono_error *error, gpointer data)
+{
+	struct rilmodem_sms_data *rsd = data;
+	const struct sms_data *sd = rsd->test_data;
+
+	g_assert(error->type == sd->error_type);
+
+	g_main_loop_quit(mainloop);
+}
+
+static void submit_callback(const struct ofono_error *error, int mr,
+								gpointer data)
+{
+	struct rilmodem_sms_data *rsd = data;
+	const struct sms_data *sd = rsd->test_data;
+
+	g_assert(error->type == sd->error_type);
+	g_assert(mr == sd->mr);
+
+	g_main_loop_quit(mainloop);
+}
+
+static gboolean trigger_sca_query(gpointer data)
+{
+	struct rilmodem_sms_data *rsd = data;
+
+	g_assert(smsdriver->sca_query != NULL);
+	smsdriver->sca_query(rsd->sms, sca_query_callback, rsd);
+
+	return FALSE;
+}
+
+static gboolean trigger_sca_set(gpointer data)
+{
+	struct rilmodem_sms_data *rsd = data;
+	const struct sms_data *sd = rsd->test_data;
+
+	g_assert(smsdriver->sca_set != NULL);
+	smsdriver->sca_set(rsd->sms, &sd->ph, sca_set_callback, rsd);
+
+	return FALSE;
+}
+
+static gboolean trigger_submit(gpointer data)
+{
+	struct rilmodem_sms_data *rsd = data;
+	const struct sms_data *sd = rsd->test_data;
+
+	g_assert(smsdriver->submit != NULL);
+
+	smsdriver->submit(rsd->sms, sd->pdu, sd->pdu_len, sd->tpdu_len,
+						sd->mms, submit_callback, rsd);
+
+	return FALSE;
+}
+
+static gboolean trigger_new_sms(gpointer data)
+{
+	struct rilmodem_sms_data *rsd = data;
+	const struct sms_data *sd = rsd->test_data;
+
+	rilmodem_test_server_write(rsd->serverd, sd->rtd.req_data,
+							sd->rtd.req_size);
+
+	return FALSE;
+}
+
+/* RIL_REQUEST_GET_SMSC_ADDRESS */
+static const guchar req_get_smsc_address_parcel_1[] = {
+	0x00, 0x00, 0x00, 0x08, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+
+/*
+ * RIL_REQUEST_GET_SMSC_ADDRESS reply with the following data:
+ *
+ * {number="[phone]"}
+ */
+static const guchar rsp_get_smsc_address_data_1[] = {
+	0x0d, 0x00, 0x00, 0x00, 0x22, 0x00, 0x2b, 0x00, 0x33, 0x00, 0x34, 0x00,
+	0x36, 0x00, 0x30, 0x00, 0x37, 0x00, 0x30, 0x00, 0x30, 0x00, 0x33, 0x00,
+	0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static const struct sms_data testdata_sca_query_valid_1 = {
+	.start_func = trigger_sca_query,
+	.rtd = {
+		.req_data = req_get_smsc_address_parcel_1,
+		.req_size = sizeof(req_get_smsc_address_parcel_1),
+		.rsp_data = rsp_get_smsc_address_data_1,
+		.rsp_size = sizeof(rsp_get_smsc_address_data_1),
+		.rsp_error = RIL_E_SUCCESS,
+	},
+	.ph = { .number = "34607003110", .type = 145 },
+	.error_type = OFONO_ERROR_TYPE_NO_ERROR,
+};
+
+/*
+ * RIL_REQUEST_GET_SMSC_ADDRESS reply with no data, which should
+ * trigger a callback failure.
+ */
+static const struct sms_data testdata_sca_query_invalid_1 = {
+	.start_func = trigger_sca_query,
+	.rtd = {
+		.req_data = req_get_smsc_address_parcel_1,
+		.req_size = sizeof(req_get_smsc_address_parcel_1),
+		.rsp_error = RIL_E_SUCCESS,
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/*
+ * RIL_REQUEST_GET_SMSC_ADDRESS reply with no quotes found which
+ * should trigger a callback failure.
+ */
+static const guchar rsp_get_smsc_address_data_3[] = {
+	0x02, 0x00, 0x00, 0x00, 0x22, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static const struct sms_data testdata_sca_query_invalid_2 = {
+	.start_func = trigger_sca_query,
+	.ph = { .number = "34607003110", .type = 145 },
+	.rtd = {
+		.req_data = req_get_smsc_address_parcel_1,
+		.req_size = sizeof(req_get_smsc_address_parcel_1),
+		.rsp_data = rsp_get_smsc_address_data_3,
+		.rsp_size = sizeof(rsp_get_smsc_address_data_3),
+		.rsp_error = RIL_E_SUCCESS,
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/* GENERIC_FAILURE returned in RIL reply */
+static const struct sms_data testdata_sca_query_invalid_3 = {
+	.start_func = trigger_sca_query,
+	.rtd = {
+		.req_data = req_get_smsc_address_parcel_1,
+		.req_size = sizeof(req_get_smsc_address_parcel_1),
+		.rsp_error = RIL_E_GENERIC_FAILURE,
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/*
+ * RIL_REQUEST_SET_SMSC_ADDRESS with the following data:
+ *
+ * {number="[phone]"}
+ */
+static const guchar req_set_smsc_address_parcel_1[] = {
+	+0x00, 0x00, 0x00, 0x2C, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	+0x0e, 0x00, 0x00, 0x00, 0x22, 0x00, 0x2b, 0x00, 0x33, 0x00, 0x34, 0x00,
+	+0x36, 0x00, 0x30, 0x00, 0x37, 0x00, 0x30, 0x00, 0x30, 0x00, 0x33, 0x00,
+	+0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static const struct sms_data testdata_sca_set_valid_1 = {
+	.start_func = trigger_sca_set,
+	.ph = { .number = "34607003110", .type = 145 },
+	.rtd = {
+		.req_data = req_set_smsc_address_parcel_1,
+		.req_size = sizeof(req_set_smsc_address_parcel_1),
+		.rsp_error = RIL_E_SUCCESS,
+	},
+	.error_type = OFONO_ERROR_TYPE_NO_ERROR,
+};
+
+/* GENERIC_FAILURE returned in RIL reply */
+static const struct sms_data testdata_sca_set_invalid_1 = {
+	.start_func = trigger_sca_set,
+	.ph = { .number = "34607003110", .type = 145 },
+	.rtd = {
+		.req_data = req_set_smsc_address_parcel_1,
+		.req_size = sizeof(req_set_smsc_address_parcel_1),
+		.rsp_error = RIL_E_GENERIC_FAILURE,
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+static const unsigned char req_send_sms_pdu_valid_1[] = {
+	0x00, 0x11, 0x00, 0x09, 0x81, 0x36, 0x54, 0x39, 0x80, 0xf5, 0x00, 0x00,
+	0xa7, 0x0a, 0xc8, 0x37, 0x3b, 0x0c, 0x6a, 0xd7, 0xdd, 0xe4, 0x37
+};
+
+static const guchar req_send_sms_parcel_1[] = {
+	0x00, 0x00, 0x00, 0x70, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x2c, 0x00, 0x00, 0x00,
+	0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x39, 0x00,
+	0x38, 0x00, 0x31, 0x00, 0x33, 0x00, 0x36, 0x00, 0x35, 0x00, 0x34, 0x00,
+	0x33, 0x00, 0x39, 0x00, 0x38, 0x00, 0x30, 0x00, 0x46, 0x00, 0x35, 0x00,
+	0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x41, 0x00, 0x37, 0x00,
+	0x30, 0x00, 0x41, 0x00, 0x43, 0x00, 0x38, 0x00, 0x33, 0x00, 0x37, 0x00,
+	0x33, 0x00, 0x42, 0x00, 0x30, 0x00, 0x43, 0x00, 0x36, 0x00, 0x41, 0x00,
+	0x44, 0x00, 0x37, 0x00, 0x44, 0x00, 0x44, 0x00, 0x45, 0x00, 0x34, 0x00,
+	0x33, 0x00, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/*
+ * SEND_SMS reply with the following data:
+ *
+ * messageRef=1
+ * ackPDU=NULL
+ * errorCode=0
+ */
+static const guchar rsp_send_sms_valid_1[] = {
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	0x00, 0x00, 0x00, 0x00
+};
+
+static const struct sms_data testdata_submit_valid_1 = {
+	.start_func = trigger_submit,
+	.pdu = req_send_sms_pdu_valid_1,
+	.pdu_len = sizeof(req_send_sms_pdu_valid_1),
+	.tpdu_len = sizeof(req_send_sms_pdu_valid_1) - 1,
+	.mms = 0,
+	.rtd = {
+		.req_data = req_send_sms_parcel_1,
+		.req_size = sizeof(req_send_sms_parcel_1),
+		.rsp_data = rsp_send_sms_valid_1,
+		.rsp_size = sizeof(rsp_send_sms_valid_1),
+		.rsp_error = RIL_E_SUCCESS,
+	},
+	.mr = 1,
+	.error_type = OFONO_ERROR_TYPE_NO_ERROR,
+};
+
+/*
+ * SEND_SMS reply with failure indicated
+ */
+static const struct sms_data testdata_submit_invalid_1 = {
+	.start_func = trigger_submit,
+	.pdu = req_send_sms_pdu_valid_1,
+	.pdu_len = sizeof(req_send_sms_pdu_valid_1),
+	.tpdu_len = sizeof(req_send_sms_pdu_valid_1) - 1,
+	.mms = 0,
+	.rtd = {
+		.req_data = req_send_sms_parcel_1,
+		.req_size = sizeof(req_send_sms_parcel_1),
+		.rsp_error = RIL_E_GENERIC_FAILURE,
+	},
+	.error_type = OFONO_ERROR_TYPE_FAILURE,
+};
+
+/*
+ * The following hexadecimal data represents a serialized Binder parcel
+ * instance containing a valid RIL_UNSOL_RESPONSE_NEW_SMS message
+ * with the following parameter (SMSC address length is 7):
+ *
+ * {07914306073011F0040B914336543980F50000310113212002400AC8373B0C6AD7DDE437}
+ * {069143060730F0040B914336543980F50000310113212002400AC8373B0C6AD7DDE437}
+ */
+static const guchar unsol_response_new_sms_parcel_1[] = {
+	0x00, 0x00, 0x00, 0xA0, 0x01, 0x00, 0x00, 0x00, 0xEB, 0x03, 0x00, 0x00,
+	0x48, 0x00, 0x00, 0x00, 0x30, 0x00, 0x37, 0x00, 0x39, 0x00, 0x31, 0x00,
+	0x34, 0x00, 0x33, 0x00, 0x30, 0x00, 0x36, 0x00, 0x30, 0x00, 0x37, 0x00,
+	0x33, 0x00, 0x30, 0x00, 0x31, 0x00, 0x31, 0x00, 0x46, 0x00, 0x30, 0x00,
+	0x30, 0x00, 0x34, 0x00, 0x30, 0x00, 0x42, 0x00, 0x39, 0x00, 0x31, 0x00,
+	0x34, 0x00, 0x33, 0x00, 0x33, 0x00, 0x36, 0x00, 0x35, 0x00, 0x34, 0x00,
+	0x33, 0x00, 0x39, 0x00, 0x38, 0x00, 0x30, 0x00, 0x46, 0x00, 0x35, 0x00,
+	0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x33, 0x00, 0x31, 0x00,
+	0x30, 0x00, 0x31, 0x00, 0x31, 0x00, 0x33, 0x00, 0x32, 0x00, 0x31, 0x00,
+	0x32, 0x00, 0x30, 0x00, 0x30, 0x00, 0x32, 0x00, 0x34, 0x00, 0x30, 0x00,
+	0x30, 0x00, 0x41, 0x00, 0x43, 0x00, 0x38, 0x00, 0x33, 0x00, 0x37, 0x00,
+	0x33, 0x00, 0x42, 0x00, 0x30, 0x00, 0x43, 0x00, 0x36, 0x00, 0x41, 0x00,
+	0x44, 0x00, 0x37, 0x00, 0x44, 0x00, 0x44, 0x00, 0x45, 0x00, 0x34, 0x00,
+	0x33, 0x00, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+const unsigned char new_sms_pdu_valid_1[] = {
+	0x07, 0x91, 0x43, 0x06, 0x07, 0x30, 0x11, 0xf0, 0x04, 0x0b, 0x91, 0x43,
+	0x36, 0x54, 0x39, 0x80, 0xf5, 0x00, 0x00, 0x31, 0x01, 0x13, 0x21, 0x20,
+	0x02, 0x40, 0x0a, 0xc8, 0x37, 0x3b, 0x0c, 0x6a, 0xd7, 0xdd, 0xe4, 0x37
+};
+
+static const struct sms_data testdata_new_sms_valid_1 = {
+	.start_func = trigger_new_sms,
+	.rtd = {
+		.req_data = unsol_response_new_sms_parcel_1,
+		.req_size = sizeof(unsol_response_new_sms_parcel_1),
+		.unsol_test = TRUE,
+	},
+	.pdu = new_sms_pdu_valid_1,
+	.pdu_len = sizeof(new_sms_pdu_valid_1),
+	.tpdu_len = 28,
+};
+
+/*
+ * The following hexadecimal data represents a serialized Binder parcel
+ * instance containing a valid UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT message
+ * with the following parameter (SMSC address length is 6):
+ *
+ * {069143060730F0040B914336543980F50000310113212002400AC8373B0C6AD7DDE437}
+ */
+static const guchar unsol_response_new_sms_parcel_2[] = {
+	0x00, 0x00, 0x00, 0x9C, 0x01, 0x00, 0x00, 0x00, 0xEC, 0x03, 0x00, 0x00,
+	0x46, 0x00, 0x00, 0x00, 0x30, 0x00, 0x36, 0x00, 0x39, 0x00, 0x31, 0x00,
+	0x34, 0x00, 0x33, 0x00, 0x30, 0x00, 0x36, 0x00, 0x30, 0x00, 0x37, 0x00,
+	0x33, 0x00, 0x30, 0x00, 0x46, 0x00, 0x30, 0x00,	0x30, 0x00, 0x34, 0x00,
+	0x30, 0x00, 0x42, 0x00, 0x39, 0x00, 0x31, 0x00,	0x34, 0x00, 0x33, 0x00,
+	0x33, 0x00, 0x36, 0x00, 0x35, 0x00, 0x34, 0x00,	0x33, 0x00, 0x39, 0x00,
+	0x38, 0x00, 0x30, 0x00, 0x46, 0x00, 0x35, 0x00,	0x30, 0x00, 0x30, 0x00,
+	0x30, 0x00, 0x30, 0x00, 0x33, 0x00, 0x31, 0x00,	0x30, 0x00, 0x31, 0x00,
+	0x31, 0x00, 0x33, 0x00, 0x32, 0x00, 0x31, 0x00,	0x32, 0x00, 0x30, 0x00,
+	0x30, 0x00, 0x32, 0x00, 0x34, 0x00, 0x30, 0x00,	0x30, 0x00, 0x41, 0x00,
+	0x43, 0x00, 0x38, 0x00, 0x33, 0x00, 0x37, 0x00,	0x33, 0x00, 0x42, 0x00,
+	0x30, 0x00, 0x43, 0x00, 0x36, 0x00, 0x41, 0x00,	0x44, 0x00, 0x37, 0x00,
+	0x44, 0x00, 0x44, 0x00, 0x45, 0x00, 0x34, 0x00,	0x33, 0x00, 0x37, 0x00,
+	0x00, 0x00, 0x00, 0x00
+};
+
+const unsigned char new_sms_pdu_valid_2[] = {
+	0x06, 0x91, 0x43, 0x06, 0x07, 0x30, 0xf0, 0x04, 0x0b, 0x91, 0x43, 0x36,
+	0x54, 0x39, 0x80, 0xf5, 0x00, 0x00, 0x31, 0x01, 0x13, 0x21, 0x20, 0x02,
+	0x40, 0x0a, 0xc8, 0x37, 0x3b, 0x0c, 0x6a, 0xd7, 0xdd, 0xe4, 0x37
+};
+
+static const struct sms_data testdata_new_sms_valid_2 = {
+	.start_func = trigger_new_sms,
+	.rtd = {
+		.req_data = unsol_response_new_sms_parcel_2,
+		.req_size = sizeof(unsol_response_new_sms_parcel_2),
+		.unsol_test = TRUE,
+	},
+	.pdu = new_sms_pdu_valid_2,
+	.pdu_len = sizeof(new_sms_pdu_valid_2),
+	.tpdu_len = 28,
+};
+
+/* Declarations && Re-implementations of core functions. */
+void ril_sms_exit(void);
+void ril_sms_init(void);
+
+struct ofono_sms {
+	void *driver_data;
+	const struct sms_data *sd;
+};
+
+struct ofono_sms *ofono_sms_create(struct ofono_modem *modem,
+					unsigned int vendor,
+					const char *driver,
+					void *data)
+{
+	struct rilmodem_sms_data *rsd = data;
+	struct ofono_sms *sms = g_new0(struct ofono_sms, 1);
+	int retval;
+
+	retval = smsdriver->probe(sms, OFONO_RIL_VENDOR_AOSP, rsd->ril);
+	g_assert(retval == 0);
+
+	return sms;
+}
+
+int ofono_sms_driver_register(const struct ofono_sms_driver *d)
+{
+	if (smsdriver == NULL)
+		smsdriver = d;
+
+	return 0;
+}
+
+void ofono_sms_set_data(struct ofono_sms *sms, void *data)
+{
+	sms->driver_data = data;
+}
+
+void *ofono_sms_get_data(struct ofono_sms *sms)
+{
+	return sms->driver_data;
+}
+
+void ofono_sms_register(struct ofono_sms *sms)
+{
+}
+
+void ofono_sms_driver_unregister(const struct ofono_sms_driver *d)
+{
+}
+
+void ofono_sms_deliver_notify(struct ofono_sms *sms, const unsigned char *pdu,
+							int len, int tpdu_len)
+{
+	g_assert(sms->sd->pdu_len == len);
+	g_assert(sms->sd->tpdu_len == tpdu_len);
+	g_assert(!memcmp(pdu, sms->sd->pdu, len));
+
+	g_main_loop_quit(mainloop);
+}
+
+void ofono_sms_status_notify(struct ofono_sms *sms, const unsigned char *pdu,
+							int len, int tpdu_len)
+{
+	ofono_sms_deliver_notify(sms, pdu, len, tpdu_len);
+}
+
+/*
+ * As all our architectures are little-endian except for
+ * PowerPC, and the Binder wire-format differs slightly
+ * depending on endian-ness, the following guards against test
+ * failures when run on PowerPC.
+ */
+#if BYTE_ORDER == LITTLE_ENDIAN
+
+static void server_connect_cb(gpointer data)
+{
+	struct rilmodem_sms_data *rsd = data;
+	const struct sms_data *sd = rsd->test_data;
+
+	/* This causes local impl of _create() to call driver's probe func. */
+	rsd->sms = ofono_sms_create(NULL, OFONO_RIL_VENDOR_AOSP,
+							"rilmodem", rsd);
+	rsd->sms->sd = sd;
+
+	/* add_idle doesn't work, read blocks main loop!!! */
+
+	if (sd->rtd.unsol_test)
+		g_idle_add(sd->start_func, (void *) rsd);
+	else
+		g_assert(sd->start_func(rsd) == FALSE);
+}
+
+/*
+ * This unit test:
+ *  - does some test data setup
+ *  - configures a dummy server socket
+ *  - creates a new gril client instance
+ *    - triggers a connect to the dummy
+ *      server socket
+ *  - starts a mainloop
+ */
+static void test_sms_func(gconstpointer data)
+{
+	const struct sms_data *sd = data;
+	struct rilmodem_sms_data *rsd;
+
+	ril_sms_init();
+
+	rsd = g_new0(struct rilmodem_sms_data, 1);
+
+	rsd->test_data = sd;
+
+	rsd->serverd = rilmodem_test_server_create(&server_connect_cb,
+								&sd->rtd, rsd);
+
+	rsd->ril = g_ril_new(rilmodem_test_get_socket_name(rsd->serverd),
+							OFONO_RIL_VENDOR_AOSP);
+	g_assert(rsd->ril != NULL);
+
+	mainloop = g_main_loop_new(NULL, FALSE);
+
+	g_main_loop_run(mainloop);
+	g_main_loop_unref(mainloop);
+
+	smsdriver->remove(rsd->sms);
+	g_ril_unref(rsd->ril);
+	g_free(rsd);
+