Merge branch 'jb33872' into 'master'

Fix eternal loop loop with roaming SIM

When ofono core is asking gprs driver to detach (because data roaming is disabled), it's expecting data registration status to change. If that doesn't happen, it starts all over again.

See merge request !22

ofono/AUTHORS

@@ -92,3 +92,10 @@ Jesper Larsen <jesper.larsen@ixonos.com>
 Slava Monich <slava.monich@jolla.com>
 Andrew Earl <andrewx.earl@intel.com>
 Krzysztof Wilk <krzysztofx.wilk@intel.com>
+Tony Espy <espy@canonical.com>
+Martin Pitt <martin.pitt@ubuntu.com>
+Alfonso Sanchez-Beato <alfonso.sanchez-beato@canonical.com>
+Jussi Pakkanen <jussi.pakkanen@canonical.com>
+Sergio Checa Blanco <sergio.checa@bmw-carit.de>
+Philip Paeps <philip@paeps.cx>
+Kuba Pawlak <kubax.t.pawlak@intel.com>

ofono/ChangeLog

@@ -1,3 +1,23 @@
+ver 1.16:
+	Fix issue with PIN retry handling.
+	Fix issue with HFP and multiple calls.
+	Add support for Distracted Driving Reduction.
+	Add support for available technologies property.
+	Add support for Telit location reporting driver.
+	Add support for u-blox SARA-U270 modems.
+	Add support for Quectel UC15 modems.
+
+ver 1.15:
+	Fix issue with EF_PNN access affecting PLMN display.
+	Fix issue with SIM detection and Telit HE910 modems.
+	Fix issue with Mobile Provider Database provisioning.
+	Fix issue with bit-shifting and ID mapping allocations.
+	Fix issue with Handsfree and unsolicited notifications.
+	Fix issue with Handsfree and three way calling feature.
+	Add support for Handsfree subscriber number feature.
+	Add support for Handsfree multiple DTMF characters.
+	Add support for PAP authentication.
+
 ver 1.14:
 	Add support for Apple Siri specific Handsfree commands.
 	Add support for provisioning of MMSC and Message Proxy.

ofono/Makefile.am

@@ -21,8 +21,9 @@ pkginclude_HEADERS = include/log.h include/plugin.h include/history.h \
 			include/cdma-connman.h include/gnss.h \
 			include/private-network.h include/cdma-netreg.h \
 			include/cdma-provision.h include/handsfree.h \
-			include/handsfree-audio.h include/sim-mnclength.h \
-			include/oemraw.h include/siri.h
+			include/handsfree-audio.h \
+			include/sim-mnclength.h include/oemraw.h \
+			include/siri.h
 
 nodist_pkginclude_HEADERS = include/version.h
 
@@ -118,8 +119,46 @@ builtin_sources += plugins/udevng.c
 endif
 
 if RILMODEM
+if JOLLA_RILMODEM
+builtin_modules += ril
+builtin_sources +=	drivers/ril/ril_call_barring.c \
+			drivers/ril/ril_call_forward.c \
+			drivers/ril/ril_call_settings.c \
+			drivers/ril/ril_call_volume.c \
+			drivers/ril/ril_cbs.c \
+			drivers/ril/ril_data.c \
+			drivers/ril/ril_devinfo.c \
+			drivers/ril/ril_gprs.c \
+			drivers/ril/ril_gprs_context.c \
+			drivers/ril/ril_mce.c \
+			drivers/ril/ril_modem.c \
+			drivers/ril/ril_netreg.c \
+			drivers/ril/ril_network.c \
+			drivers/ril/ril_oem_raw.c \
+			drivers/ril/ril_phonebook.c \
+			drivers/ril/ril_plugin.c \
+			drivers/ril/ril_plugin_dbus.c \
+			drivers/ril/ril_radio.c \
+			drivers/ril/ril_radio_settings.c \
+			drivers/ril/ril_sim.c \
+			drivers/ril/ril_sim_card.c \
+			drivers/ril/ril_sim_dbus.c \
+			drivers/ril/ril_sms.c \
+			drivers/ril/ril_stk.c \
+			drivers/ril/ril_ussd.c \
+			drivers/ril/ril_util.c \
+			drivers/ril/ril_voicecall.c
+
+if DATAFILES
+dist_conf_DATA += drivers/ril/ril_subscription.conf
+endif
+
+else
 builtin_sources += $(gril_sources)
 
+builtin_modules += rildev
+builtin_sources += plugins/rildev.c
+
 builtin_modules += ril
 builtin_sources += plugins/ril.c
 
@@ -142,8 +181,15 @@ builtin_sources += drivers/rilmodem/rilmodem.h \
 			drivers/rilmodem/call-settings.c \
 			drivers/rilmodem/call-forwarding.c \
 			drivers/rilmodem/cbs.c \
-			drivers/rilmodem/oemraw-messages.c
+			drivers/rilmodem/oemraw-messages.c \
+			drivers/rilmodem/call-barring.c \
+			drivers/rilmodem/stk.c
 
+if DATAFILES
+dist_conf_DATA += gril/ril_subscription.conf
+endif
+
+endif
 endif
 
 if ISIMODEM
@@ -307,6 +353,12 @@ builtin_sources += drivers/atmodem/atutil.h \
 			drivers/mbmmodem/stk.c \
 			drivers/mbmmodem/location-reporting.c
 
+builtin_modules += telitmodem
+builtin_sources += drivers/atmodem/atutil.h \
+			drivers/telitmodem/telitmodem.h \
+			drivers/telitmodem/telitmodem.c \
+			drivers/telitmodem/location-reporting.c
+
 builtin_modules += hsomodem
 builtin_sources += drivers/atmodem/atutil.h \
 			drivers/hsomodem/hsomodem.h \
@@ -369,9 +421,6 @@ builtin_sources += plugins/phonesim.c
 
 if DATAFILES
 dist_conf_DATA += plugins/phonesim.conf
-if RILMODEM
-dist_conf_DATA += gril/ril_subscription.conf
-endif
 endif
 endif
 
@@ -456,14 +505,20 @@ builtin_sources += plugins/samsung.c
 
 builtin_modules += sim900
 builtin_sources += plugins/sim900.c
+
+builtin_modules += quectel
+builtin_sources += plugins/quectel.c
+
+builtin_modules += ublox
+builtin_sources += plugins/ublox.c
+
+builtin_modules += he910
+builtin_sources += plugins/he910.c
 endif
 
 builtin_modules += connman
 builtin_sources += plugins/connman.c
 
-builtin_modules += he910
-builtin_sources += plugins/he910.c
-
 if BLUETOOTH
 if BLUEZ4
 builtin_modules += bluez4
@@ -512,7 +567,7 @@ if PROVISION
 builtin_sources += plugins/mbpi.h plugins/mbpi.c
 
 builtin_modules += provision
-builtin_sources += plugins/provision.c
+builtin_sources += plugins/provision.h plugins/provision.c
 
 builtin_modules += cdma_provision
 builtin_sources += plugins/cdma-provision.c
@@ -539,6 +594,9 @@ builtin_sources += examples/private-network.c
 
 builtin_modules += stktest
 builtin_sources += plugins/stktest.c
+
+builtin_modules += emulator_fuzz
+builtin_sources += plugins/emulator_fuzz.c
 endif
 
 builtin_modules += smart_messaging
@@ -547,6 +605,18 @@ builtin_sources += plugins/smart-messaging.c
 builtin_modules += push_notification
 builtin_sources += plugins/push-notification.c
 
+if PUSHFORWARDER
+builtin_modules += push_forwarder
+builtin_sources += plugins/push-forwarder.c
+builtin_cflags += @WSPCODEC_CFLAGS@
+builtin_libadd += @WSPCODEC_LIBS@
+endif
+
+if LOGCONTROL
+builtin_modules += debuglog
+builtin_sources += plugins/debuglog.c
+endif
+
 builtin_modules += sms_history
 builtin_sources += plugins/smshistory.c
 
@@ -577,8 +647,8 @@ src_ofonod_SOURCES = $(builtin_sources) src/ofono.ver \
 			src/cdma-sms.c src/private-network.c src/cdma-netreg.c \
 			src/cdma-provision.c src/handsfree.c \
 			src/handsfree-audio.c src/bluetooth.h \
-			src/hfp.h src/sim-mnclength.c src/oemraw.c \
-			src/siri.c
+			src/sim-mnclength.c src/oemraw.c src/voicecallagent.c \
+			src/hfp.h src/siri.c
 
 src_ofonod_LDADD = gdbus/libgdbus-internal.la $(builtin_libadd) \
 			@GLIB_LIBS@ @DBUS_LIBS@ -ldl
@@ -621,9 +691,10 @@ doc_files = doc/overview.txt doc/ofono-paper.txt doc/release-faq.txt \
 			doc/sim-api.txt doc/stk-api.txt \
 			doc/audio-settings-api.txt doc/text-telephony-api.txt \
 			doc/calypso-modem.txt doc/message-api.txt \
-			doc/location-reporting-api.txt doc/smshistory-api.txt \
-			doc/oemraw-api.txt \
-			doc/certification.txt doc/siri-api.txt
+			doc/location-reporting-api.txt \
+			doc/smshistory-api.txt doc/oemraw-api.txt \
+			doc/certification.txt doc/siri-api.txt \
+			doc/telit-modem.txt
 
 
 test_scripts = test/backtrace \
@@ -711,13 +782,17 @@ test_scripts = test/backtrace \
 		test/set-context-property \
 		test/test-gnss \
 		test/swap-calls \
+		test/transfer-call \
 		test/release-and-answer \
 		test/release-and-swap \
 		test/hold-and-answer \
 		test/hangup-multiparty \
 		test/hangup-call \
 		test/display-icon \
-		test/set-msisdn
+		test/set-msisdn \
+		test/test-voicecallagent \
+		test/get-network-time \
+		test/set-ddr
 
 if TEST
 testdir = $(pkglibdir)/test
@@ -738,7 +813,8 @@ unit_tests = unit/test-common unit/test-util unit/test-idmap \
 				unit/test-grilrequest \
 				unit/test-grilreply \
 				unit/test-grilunsol \
-				unit/test-sms unit/test-cdmasms
+				unit/test-sms unit/test-cdmasms \
+				unit/test-provision
 
 noinst_PROGRAMS = $(unit_tests) \
 			unit/test-sms-root unit/test-mux unit/test-caif
@@ -805,6 +881,13 @@ unit_test_grilunsol_SOURCES = unit/test-grilunsol.c $(gril_sources) \
 unit_test_grilunsol_LDADD = @GLIB_LIBS@ -ldl
 unit_objects += $(unit_test_grilunsol_OBJECTS)
 
+unit_test_provision_SOURCES = unit/test-provision.c \
+				plugins/provision.h plugins/provision.c \
+				plugins/mbpi.c src/gprs-provision.c \
+				src/log.c
+unit_test_provision_LDADD = @GLIB_LIBS@ -ldl
+unit_objects += $(unit_test_provision_OBJECTS)
+
 TESTS = $(unit_tests)
 
 if TOOLS

ofono/acinclude.m4

@@ -12,7 +12,7 @@ AC_DEFUN([AC_PROG_CC_PIE], [
 
 AC_DEFUN([COMPILER_FLAGS], [
 	if (test "${CFLAGS}" = ""); then
-		CFLAGS="-Wall -O2 -D_FORTIFY_SOURCE=2"
+		CFLAGS="-Wall -O2 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2"
 	fi
 	if (test "$USE_MAINTAINER_MODE" = "yes"); then
 		CFLAGS="$CFLAGS -Werror -Wextra"

ofono/configure.ac

@@ -1,5 +1,5 @@
 AC_PREREQ(2.60)
-AC_INIT(ofono, 1.14)
+AC_INIT(ofono, 1.16)
 
 AM_INIT_AUTOMAKE([foreign subdir-objects color-tests])
 AC_CONFIG_HEADERS(config.h)
@@ -42,6 +42,7 @@ AC_ARG_ENABLE(debug, AC_HELP_STRING([--enable-debug],
 	if (test "${enableval}" = "yes" &&
 				test "${ac_cv_prog_cc_g}" = "yes"); then
 		CFLAGS="$CFLAGS -g"
+                CPPFLAGS="$CPPFLAGS -DDEBUG"
 	fi
 ])
 
@@ -166,6 +167,20 @@ AC_ARG_ENABLE(rilmodem, AC_HELP_STRING([--disable-rilmodem],
                                         [enable_rilmodem=${enableval}])
 AM_CONDITIONAL(RILMODEM, test "${enable_rilmodem}" != "no")
 
+AC_ARG_ENABLE(jolla-rilmodem,
+        AC_HELP_STRING([--enable-jolla-rilmodem], [enable Jolla RIL modem]),
+        [enable_jolla_rilmodem=${enableval}], [enable_jolla_rilmodem="no"])
+AM_CONDITIONAL(JOLLA_RILMODEM, test "${enable_jolla_rilmodem}" != "no")
+
+if (test "${enable_jolla_rilmodem}" = "yes"); then
+	PKG_CHECK_MODULES(GRILIO, libgrilio >= 1.0.6, dummy=yes,
+				AC_MSG_ERROR(libgrilio >= 1.0.6 is required))
+	PKG_CHECK_MODULES(GLIBUTIL, libglibutil, dummy=yes,
+				AC_MSG_ERROR(libglibutil is required))
+	CFLAGS="$CFLAGS $GRILIO_CFLAGS $GLIBUTIL_CFLAGS"
+	LIBS="$LIBS $GRILIO_LIBS $GLIBUTIL_LIBS"
+fi
+
 AC_ARG_ENABLE(qmimodem, AC_HELP_STRING([--disable-qmimodem],
 				[disable Qualcomm QMI modem support]),
 					[enable_qmimodem=${enableval}])
@@ -192,7 +207,10 @@ AM_CONDITIONAL(BLUETOOTH, test "${enable_bluetooth}" != "no")
 AC_ARG_ENABLE(nettime, AC_HELP_STRING([--disable-nettime],
                                 [disable Nettime plugin]),
                                         [enable_nettime=${enableval}])
-AM_CONDITIONAL(NETTIME, test "${enable_netttime}" != "no")
+if (test "${enable_nettime}" != "no"); then
+	AC_SEARCH_LIBS([clock_gettime], [rt])
+fi
+AM_CONDITIONAL(NETTIME, test "${enable_nettime}" != "no")
 
 AC_ARG_WITH([provisiondb], AC_HELP_STRING([--with-provisiondb=FILE],
 	[location of provision database]), [path_provisiondb=${withval}])
@@ -223,6 +241,22 @@ AC_ARG_ENABLE(datafiles, AC_HELP_STRING([--disable-datafiles],
 					[enable_datafiles=${enableval}])
 AM_CONDITIONAL(DATAFILES, test "${enable_datafiles}" != "no")
 
+AC_ARG_ENABLE(pushforwarder, AC_HELP_STRING([--disable-pushforwarder],
+                                [disable Push Forwarder plugin]),
+                                        [enable_pushforwarder=${enableval}])
+AM_CONDITIONAL(PUSHFORWARDER, test "${enable_pushforwarder}" != "no")
+if (test "${enable_pushforwarder}" != "no"); then
+	PKG_CHECK_MODULES(WSPCODEC, libwspcodec >= 2.0, dummy=yes,
+		AC_MSG_ERROR(WSP decoder is required))
+	AC_SUBST(WSPCODEC_CFLAGS)
+	AC_SUBST(WSPCODEC_LIBS)
+fi
+
+AC_ARG_ENABLE(logcontrol,
+	AC_HELP_STRING([--enable-logcontrol], [enable log control plugin]),
+			[enable_logcontrol=${enableval}], [enable_logcontrol="no"])
+AM_CONDITIONAL(LOGCONTROL, test "${enable_logcontrol}" != "no")
+
 if (test "${prefix}" = "NONE"); then
 	dnl no prefix and no localstatedir, so default to /var
 	if (test "$localstatedir" = '${prefix}/var'); then

ofono/doc/connman-api.txt

@@ -155,6 +155,15 @@ Methods		dict GetProperties()
 					 [service].Error.AttachInProgress
 					 [service].Error.NotImplemented
 
+Methods		void ProvisionContext()
+			Resets all properties back to default. Fails to make
+			any changes to the context if it is active or in the
+			process of being activated or deactivated.
+
+			Possible Errors: [service].Error.Failed
+					 [service].Error.InProgress
+					 [service].Error.NotAvailable
+
 Signals		PropertyChanged(string property, variant value)
 
 			This signal indicates a changed value of the given
@@ -180,6 +189,10 @@ Properties	boolean Active [readwrite]
 				"wap" - Used by WAP related services
 				"ims" - Used by IMS related services
 
+		string AuthenticationMethod [readwrite]
+			Holds the PPP authentication method to use.  Valid
+			values are "pap" and "chap".  Defaults to "chap".
+
 		string Username [readwrite]
 
 			Holds the username to be used for authentication

ofono/doc/debuglog-api.txt

@@ -0,0 +1,28 @@
+Debug log control
+=================
+
+Service		org.ofono
+Interface	org.ofono.DebugLog
+Object path	/
+
+Methods		void Enable(string pattern)
+
+			Enables all logs that match the pattern.
+
+		void Disable(string pattern)
+
+			Disables all logs that match the pattern.
+
+		array(string,boolean) List()
+
+			Returns all available log names and their current
+			states.
+
+			In order for Enable or Disable call to have any
+			effect, the pattern must match one or more of
+			these strings.
+
+Signals		Changed(string name, boolean enabled)
+
+			This signal indicates a changed log status of the
+			given log module.

ofono/doc/handsfree-api.txt

@@ -19,6 +19,8 @@ Methods		dict GetProperties()
 
 			Possible Errors: [service].Error.InProgress
 					 [service].Error.InvalidArguments
+					 [service].Error.NotImplemented
+					 [service].Error.NotSupported
 
 		string RequestPhoneNumber()
 
@@ -45,6 +47,13 @@ Properties	array{string} Features [readonly]
 				"voice-recognition"
 				"attach-voice-tag"
 				"echo-canceling-and-noise-reduction"
+				"three-way-calling"
+				"release-all-held"
+				"release-specified-active-call"
+				"private-chat"
+				"create-multiparty"
+				"transfer"
+				"hf-indicators"
 
 		boolean InbandRinging [readonly]
 
@@ -57,7 +66,7 @@ Properties	array{string} Features [readonly]
 			to activate or deactivate the function from the HF, or
 			the AG could autonomously initiate it.
 
-		boolean EchoCancelingNoiseReduction [readwrite]
+		boolean EchoCancelingNoiseReduction [readwrite, optional]
 
 			Non-persistent Boolean property representing whether
 			echo canceling and noise reduction is enabled in the
@@ -70,3 +79,14 @@ Properties	array{string} Features [readonly]
 
 			The current charge level of the battery.  The value
 			can be between 0 and 5 respectively.
+
+		array{string} SubscriberNumbers [readonly]
+
+			List of subscriber numbers provided by the AG.
+
+		boolean DistractedDrivingReduction [readwrite, optional]
+
+			Non-persistent property representing whether
+			distracted driving reduction mode should be enabled in
+			the AG.  Support for this feature is optional on the
+			AG.

ofono/doc/network-api.txt

@@ -57,6 +57,11 @@ Signals		PropertyChanged(string property, variant value)
 			This signal indicates a changed value of the given
 			property.
 
+		OperatorsChanged(array{object,dict})
+
+			Signal that gets emitted when operator list has
+			changed. It contains the current list of operators.
+
 Properties	string Mode [readonly]
 
 			The current registration mode. The default of this

ofono/doc/radio-settings-api.txt

@@ -45,6 +45,11 @@ Properties	string TechnologyPreference [readwrite]
 				"umts"	Only UMTS used for radio access.
 				"lte"	Only LTE used for radio access.
 
+		array{string} AvailableTechnologies [readonly, optional]
+
+			List of values for TechnologyPreference property
+			supported by the modem.
+
 		string GsmBand [readwrite, optional]
 
 			Frequency band in which the modem is allowed to

ofono/doc/telit-modem.txt

@@ -0,0 +1,19 @@
+oFono - Open Source Telephony
+*****************************
+
+Purpose
+=======
+The purpose of this document is to identify issues and configuration
+requirements with Telit's modems.
+
+HE910
+=====
+
+GPS:
+  To enable location reporting on the Telit HE910 the modem needs to be
+  switched to Port Configuration #8. Please refer to Telit's
+  'HE910 UE910 Family Ports Arrangements' section 4.1.3 for rationale and
+  'AT Commands Reference Guide' section 3.5.7.1.96 for specific AT command.
+  After setting the configuration, a power cycle is required.
+  Port Configiuration #8 is available since firmware 12.00.004. Firmware version
+  can be checked using 'AT+CGMR'.

ofono/doc/voicecallmanager-api.txt

@@ -198,6 +198,25 @@ Methods		dict GetProperties()
 					 [service].Error.InvalidFormat
 					 [service].Error.Failed
 
+		void RegisterVoicecallAgent(object path)
+
+			Registers an agent which will be called whenever a
+			specific voice call related event requiring a client
+			action occurs. Currently, the only such action is
+			playing a ringback tone locally.
+
+			Possible Errors: [service].Error.InProgress
+					 [service].Error.InvalidArguments
+					 [service].Error.InvalidFormat
+					 [service].Error.Failed
+
+		void UnregisterVoicecallAgent(object path)
+
+			Unregisters an agent.
+
+			Possible Errors: [service].Error.InvalidArguments
+					 [service].Error.Failed
+
 Signals		CallAdded(object path, dict properties)
 
 			Signal that is sent when a new call is added.  It
@@ -257,3 +276,26 @@ Properties	array{string} EmergencyNumbers [readonly]
 			of numbers provided by the specification and any
 			extra numbers provisioned by the carrier on the
 			SIM.
+
+VoiceCallAgent Hierarchy
+========================
+
+Service		unique name
+Interface	org.ofono.VoiceCallAgent
+Object path	freely definable
+
+Methods		void RingbackTone(boolean playTone)
+
+			Requests the client to generate an alerting tone locally
+			(3GPP 24.008; 5.2.1.5). This can happen when an outgoing
+			voice call is made and network is not providing the
+			alerting tone. Value 0 stands for "stop playing ringback
+			tone" and 1 for "start playing ringback tone".
+
+		void Release() [noreply]
+
+			Agent is being released, possibly because of oFono
+			terminating, voicecall interface is being torn down or
+			modem is switched off. No UnregisterVoicecallAgent
+			call is needed.
+

ofono/drivers/atmodem/gprs-context.c

@@ -59,6 +59,7 @@ enum state {
 struct gprs_context_data {
 	GAtChat *chat;
 	unsigned int active_context;
+	GAtPPPAuthMethod auth_method;
 	char username[OFONO_GPRS_MAX_USERNAME_LENGTH + 1];
 	char password[OFONO_GPRS_MAX_PASSWORD_LENGTH + 1];
 	GAtPPP *ppp;
@@ -154,6 +155,7 @@ static gboolean setup_ppp(struct ofono_gprs_context *gc)
 	if (getenv("OFONO_PPP_DEBUG"))
 		g_at_ppp_set_debug(gcd->ppp, ppp_debug, "PPP");
 
+	g_at_ppp_set_auth_method(gcd->ppp, gcd->auth_method);
 	g_at_ppp_set_credentials(gcd->ppp, gcd->username, gcd->password);
 
 	/* set connect and disconnect callbacks */
@@ -243,6 +245,18 @@ static void at_gprs_activate_primary(struct ofono_gprs_context *gc,
 	memcpy(gcd->username, ctx->username, sizeof(ctx->username));
 	memcpy(gcd->password, ctx->password, sizeof(ctx->password));
 
+	/* We only support CHAP and PAP */
+	switch (ctx->auth_method) {
+	case OFONO_GPRS_AUTH_METHOD_CHAP:
+		gcd->auth_method = G_AT_PPP_AUTH_METHOD_CHAP;
+		break;
+	case OFONO_GPRS_AUTH_METHOD_PAP:
+		gcd->auth_method = G_AT_PPP_AUTH_METHOD_PAP;
+		break;
+	default:
+		goto error;
+	}
+
 	gcd->state = STATE_ENABLING;
 
 	if (gcd->vendor == OFONO_VENDOR_ZTE) {
@@ -268,9 +282,34 @@ static void at_gprs_activate_primary(struct ofono_gprs_context *gc,
 
 	len = snprintf(buf, sizeof(buf), "AT+CGDCONT=%u,\"IP\"", ctx->cid);
 
-	if (ctx->apn)
-		snprintf(buf + len, sizeof(buf) - len - 3, ",\"%s\"",
-				ctx->apn);
+	if (ctx->apn) {
+		switch (gcd->vendor) {
+		case OFONO_VENDOR_UBLOX:
+			/*
+			 * U-blox modems require a magic prefix to the APN to
+			 * specify the authentication method to use in the
+			 * network.  See UBX-13002752 - R21.
+			 *
+			 * As the response of the read command omits this magic
+			 * prefix, this is the least invasive place to set it.
+			 */
+			switch (ctx->auth_method) {
+			case OFONO_GPRS_AUTH_METHOD_CHAP:
+				snprintf(buf + len, sizeof(buf) - len - 3,
+						",\"CHAP:%s\"", ctx->apn);
+				break;
+			case OFONO_GPRS_AUTH_METHOD_PAP:
+				snprintf(buf + len, sizeof(buf) - len - 3,
+						",\"PAP:%s\"", ctx->apn);
+				break;
+			}
+			break;
+		default:
+			snprintf(buf + len, sizeof(buf) - len - 3, ",\"%s\"",
+					ctx->apn);
+			break;
+		}
+	}
 
 	if (g_at_chat_send(gcd->chat, buf, none_prefix,
 				at_cgdcont_cb, gc, NULL) > 0)

ofono/drivers/atmodem/gprs.c

@@ -282,6 +282,44 @@ static void telit_mode_notify(GAtResult *result, gpointer user_data)
 	ofono_gprs_bearer_notify(gprs, bearer);
 }
 
+static void ublox_ureg_notify(GAtResult *result, gpointer user_data)
+{
+	struct ofono_gprs *gprs = user_data;
+	GAtResultIter iter;
+	gint state, bearer;
+
+	g_at_result_iter_init(&iter, result);
+
+	if (!g_at_result_iter_next(&iter, "+UREG:"))
+		return;
+
+	if (!g_at_result_iter_next_number(&iter, &state))
+		return;
+
+	switch (state) {
+	case 4:
+		bearer = 5;
+		break;
+	case 5:
+		bearer = 4;
+		break;
+	case 7:
+		/* XXX: reserved - assume none. */
+		bearer = 0;
+		break;
+	case 8:
+		bearer = 1;
+		break;
+	case 9:
+		bearer = 2;
+		break;
+	default:
+		bearer = state;
+	}
+
+	ofono_gprs_bearer_notify(gprs, bearer);
+}
+
 static void cpsb_notify(GAtResult *result, gpointer user_data)
 {
 	struct ofono_gprs *gprs = user_data;
@@ -316,6 +354,12 @@ static void gprs_initialized(gboolean ok, GAtResult *result, gpointer user_data)
 		g_at_chat_register(gd->chat, "^MODE:", huawei_mode_notify,
 						FALSE, gprs, NULL);
 		break;
+	case OFONO_VENDOR_UBLOX:
+		g_at_chat_register(gd->chat, "+UREG:", ublox_ureg_notify,
+						FALSE, gprs, NULL);
+		g_at_chat_send(gd->chat, "AT+UREG=1", none_prefix,
+						NULL, NULL, NULL);
+		break;
 	case OFONO_VENDOR_TELIT:
 		g_at_chat_register(gd->chat, "#PSNT:", telit_mode_notify,
 						FALSE, gprs, NULL);

ofono/drivers/atmodem/sim.c

@@ -67,6 +67,8 @@ static const char *epin_prefix[] = { "*EPIN:", NULL };
 static const char *spic_prefix[] = { "+SPIC:", NULL };
 static const char *pct_prefix[] = { "#PCT:", NULL };
 static const char *pnnm_prefix[] = { "+PNNM:", NULL };
+static const char *qpinc_prefix[] = { "+QPINC:", NULL };
+static const char *upincnt_prefix[] = { "+UPINCNT:", NULL };
 static const char *none_prefix[] = { NULL };
 
 static void at_crsm_info_cb(gboolean ok, GAtResult *result, gpointer user_data)
@@ -967,6 +969,90 @@ error:
 	CALLBACK_WITH_FAILURE(cb, NULL, cbd->data);
 }
 
+static void at_qpinc_cb(gboolean ok, GAtResult *result, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_sim_pin_retries_cb_t cb = cbd->cb;
+	const char *final = g_at_result_final_response(result);
+	GAtResultIter iter;
+	struct ofono_error error;
+	int retries[OFONO_SIM_PASSWORD_INVALID];
+	size_t i;
+
+	decode_at_error(&error, final);
+
+	if (!ok) {
+		cb(&error, NULL, cbd->data);
+		return;
+	}
+
+	for (i = 0; i < OFONO_SIM_PASSWORD_INVALID; i++)
+		retries[i] = -1;
+
+	g_at_result_iter_init(&iter, result);
+
+	while (g_at_result_iter_next(&iter, "+QPINC:")) {
+		const char *name;
+		int pin, puk;
+
+		if (!g_at_result_iter_next_string(&iter, &name))
+			continue;
+		if (!g_at_result_iter_next_number(&iter, &pin))
+			continue;
+		if (!g_at_result_iter_next_number(&iter, &puk))
+			continue;
+
+		if (!strcmp(name, "SC")) {
+			retries[OFONO_SIM_PASSWORD_SIM_PIN] = pin;
+			retries[OFONO_SIM_PASSWORD_SIM_PUK] = puk;
+		} else if (!strcmp(name, "P2")) {
+			retries[OFONO_SIM_PASSWORD_SIM_PIN2] = pin;
+			retries[OFONO_SIM_PASSWORD_SIM_PUK2] = puk;
+		}
+	}
+
+	cb(&error, retries, cbd->data);
+}
+
+static void upincnt_cb(gboolean ok, GAtResult *result, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_sim_pin_retries_cb_t cb = cbd->cb;
+	const char *final = g_at_result_final_response(result);
+	GAtResultIter iter;
+	struct ofono_error error;
+	int retries[OFONO_SIM_PASSWORD_INVALID];
+	size_t i;
+	static enum ofono_sim_password_type password_types[] = {
+		OFONO_SIM_PASSWORD_SIM_PIN,
+		OFONO_SIM_PASSWORD_SIM_PIN2,
+		OFONO_SIM_PASSWORD_SIM_PUK,
+		OFONO_SIM_PASSWORD_SIM_PUK2,
+	};
+
+	decode_at_error(&error, final);
+
+	if (!ok) {
+		cb(&error, NULL, cbd->data);
+		return;
+	}
+
+	g_at_result_iter_init(&iter, result);
+
+	if (!g_at_result_iter_next(&iter, "+UPINCNT:"))
+		goto error;
+
+	BUILD_PIN_RETRIES_ARRAY(password_types, ARRAY_SIZE(password_types),
+				retries);
+
+	cb(&error, retries, cbd->data);
+
+	return;
+
+error:
+	CALLBACK_WITH_FAILURE(cb, NULL, cbd->data);
+}
+
 static void at_pin_retries_query(struct ofono_sim *sim,
 					ofono_sim_pin_retries_cb_t cb,
 					void *data)
@@ -1028,6 +1114,16 @@ static void at_pin_retries_query(struct ofono_sim *sim,
 					at_pnnm_cb, cbd, g_free) > 0)
 			return;
 		break;
+	case OFONO_VENDOR_QUECTEL:
+		if (g_at_chat_send(sd->chat, "AT+QPINC?", qpinc_prefix,
+					at_qpinc_cb, cbd, g_free) > 0)
+			return;
+		break;
+	case OFONO_VENDOR_UBLOX:
+		if (g_at_chat_send(sd->chat, "AT+UPINCNT", upincnt_prefix,
+					upincnt_cb, cbd, g_free) > 0)
+			return;
+		break;
 	default:
 		if (g_at_chat_send(sd->chat, "AT+CPINR", cpinr_prefixes,
 					at_cpinr_cb, cbd, g_free) > 0)

ofono/drivers/atmodem/vendor.h

@@ -42,5 +42,7 @@ enum ofono_vendor {
 	OFONO_VENDOR_SIMCOM_SIM900,
 	OFONO_VENDOR_ICERA,
 	OFONO_VENDOR_WAVECOM_Q2XXX,
-	OFONO_VENDOR_ALCATEL
+	OFONO_VENDOR_ALCATEL,
+	OFONO_VENDOR_QUECTEL,
+	OFONO_VENDOR_UBLOX,
 };

ofono/drivers/hfpmodem/handsfree.c

@@ -49,6 +49,7 @@ static const char *bvra_prefix[] = { "+BVRA:", NULL };
 struct hf_data {
 	GAtChat *chat;
 	unsigned int ag_features;
+	unsigned int ag_chld_features;
 	int battchg_index;
 	guint register_source;
 };
@@ -124,6 +125,108 @@ static void ciev_notify(GAtResult *result, gpointer user_data)
 	ofono_handsfree_battchg_notify(hf, value);
 }
 
+static void cnum_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_handsfree_cnum_query_cb_t cb = cbd->cb;
+	GAtResultIter iter;
+	struct ofono_phone_number *list = NULL;
+	int num = 0;
+	struct ofono_error error;
+
+	decode_at_error(&error, g_at_result_final_response(result));
+
+	if (!ok)
+		goto out;
+
+	g_at_result_iter_init(&iter, result);
+
+	while (g_at_result_iter_next(&iter, "+CNUM:"))
+		num++;
+
+	if (num == 0)
+		goto out;
+
+	list = g_new0(struct ofono_phone_number, num);
+
+	g_at_result_iter_init(&iter, result);
+
+	for (num = 0; g_at_result_iter_next(&iter, "+CNUM:"); ) {
+		const char *number;
+		int service;
+		int type;
+
+		if (!g_at_result_iter_skip_next(&iter))
+			continue;
+
+		if (!g_at_result_iter_next_string(&iter, &number))
+			continue;
+
+		if (!g_at_result_iter_next_number(&iter, &type))
+			continue;
+
+		if (!g_at_result_iter_skip_next(&iter))
+			continue;
+
+		if (!g_at_result_iter_next_number(&iter, &service))
+			continue;
+
+		/* We are only interested in Voice services */
+		if (service != 4)
+			continue;
+
+		strncpy(list[num].number, number,
+				OFONO_MAX_PHONE_NUMBER_LENGTH);
+		list[num].number[OFONO_MAX_PHONE_NUMBER_LENGTH] = '\0';
+		list[num].type = type;
+
+		DBG("cnum_notify:%s", list[num].number);
+		num++;
+	}
+
+out:
+	cb(&error, num, list, cbd->data);
+
+	g_free(list);
+
+}
+
+static void hfp_cnum_query(struct ofono_handsfree *hf,
+				ofono_handsfree_cnum_query_cb_t cb, void *data)
+{
+	struct hf_data *hd = ofono_handsfree_get_data(hf);
+	struct cb_data *cbd = cb_data_new(cb, data);
+
+	if (g_at_chat_send(hd->chat, "AT+CNUM", NULL,
+					cnum_query_cb, cbd, g_free) > 0)
+		return;
+
+	g_free(cbd);
+
+	CALLBACK_WITH_FAILURE(cb, -1, NULL, data);
+}
+
+static void bind_notify(GAtResult *result, gpointer user_data)
+{
+	struct ofono_handsfree *hf = user_data;
+	int hf_indicator;
+	int active;
+	GAtResultIter iter;
+
+	g_at_result_iter_init(&iter, result);
+
+	if (!g_at_result_iter_next(&iter, "+BIND:"))
+		return;
+
+	if (!g_at_result_iter_next_number(&iter, &hf_indicator))
+		return;
+
+	if (!g_at_result_iter_next_number(&iter, &active))
+		return;
+
+	ofono_handsfree_hf_indicator_active_notify(hf, hf_indicator, active);
+}
+
 static gboolean hfp_handsfree_register(gpointer user_data)
 {
 	struct ofono_handsfree *hf = user_data;
@@ -134,11 +237,13 @@ static gboolean hfp_handsfree_register(gpointer user_data)
 	g_at_chat_register(hd->chat, "+BSIR:", bsir_notify, FALSE, hf, NULL);
 	g_at_chat_register(hd->chat, "+BVRA:", bvra_notify, FALSE, hf, NULL);
 	g_at_chat_register(hd->chat, "+CIEV:", ciev_notify, FALSE, hf, NULL);
+	g_at_chat_register(hd->chat, "+BIND:", bind_notify, FALSE, hf, NULL);
 
 	if (hd->ag_features & HFP_AG_FEATURE_IN_BAND_RING_TONE)
 		ofono_handsfree_set_inband_ringing(hf, TRUE);
 
 	ofono_handsfree_set_ag_features(hf, hd->ag_features);
+	ofono_handsfree_set_ag_chld_features(hf, hd->ag_chld_features);
 	ofono_handsfree_register(hf);
 
 	return FALSE;
@@ -149,11 +254,13 @@ static int hfp_handsfree_probe(struct ofono_handsfree *hf,
 {
 	struct hfp_slc_info *info = data;
 	struct hf_data *hd;
+	unsigned int i;
 
 	DBG("");
 	hd = g_new0(struct hf_data, 1);
 	hd->chat = g_at_chat_clone(info->chat);
 	hd->ag_features = info->ag_features;
+	hd->ag_chld_features = info->ag_mpty_features;
 
 	ofono_handsfree_set_data(hf, hd);
 
@@ -161,6 +268,14 @@ static int hfp_handsfree_probe(struct ofono_handsfree *hf,
 	ofono_handsfree_battchg_notify(hf,
 					info->cind_val[HFP_INDICATOR_BATTCHG]);
 
+	ofono_handsfree_set_hf_indicators(hf, info->hf_indicators,
+						info->num_hf_indicators);
+
+	for (i = 0; i < info->num_hf_indicators; i++)
+		ofono_handsfree_hf_indicator_active_notify(hf,
+			info->hf_indicators[i],
+			info->hf_indicator_active_map & (1 << i));
+
 	hd->register_source = g_idle_add(hfp_handsfree_register, hf);
 
 	return 0;
@@ -276,13 +391,34 @@ static void hfp_disable_nrec(struct ofono_handsfree *hf,
 	CALLBACK_WITH_FAILURE(cb, data);
 }
 
+static void hfp_hf_indicator(struct ofono_handsfree *hf,
+				unsigned short indicator, unsigned int value,
+				ofono_handsfree_cb_t cb, void *data)
+{
+	struct hf_data *hd = ofono_handsfree_get_data(hf);
+	struct cb_data *cbd = cb_data_new(cb, data);
+	char buf[128];
+
+	snprintf(buf, sizeof(buf), "AT+BIEV=%u,%u", indicator, value);
+
+	if (g_at_chat_send(hd->chat, buf, NULL, hf_generic_set_cb,
+							cbd, g_free) > 0)
+		return;
+
+	g_free(cbd);
+
+	CALLBACK_WITH_FAILURE(cb, data);
+}
+
 static struct ofono_handsfree_driver driver = {
 	.name			= "hfpmodem",
 	.probe			= hfp_handsfree_probe,
 	.remove			= hfp_handsfree_remove,
+	.cnum_query		= hfp_cnum_query,
 	.request_phone_number	= hfp_request_phone_number,
 	.voice_recognition	= hfp_voice_recognition,
 	.disable_nrec		= hfp_disable_nrec,
+	.hf_indicator		= hfp_hf_indicator,
 };
 
 void hfp_handsfree_init(void)

ofono/drivers/hfpmodem/slc.c

@@ -41,10 +41,12 @@
 #include "hfp.h"
 #include "slc.h"
 
+static const char *none_prefix[] = { NULL };
 static const char *brsf_prefix[] = { "+BRSF:", NULL };
 static const char *cind_prefix[] = { "+CIND:", NULL };
 static const char *cmer_prefix[] = { "+CMER:", NULL };
 static const char *chld_prefix[] = { "+CHLD:", NULL };
+static const char *bind_prefix[] = { "+BIND:", NULL };
 
 struct slc_establish_data {
 	gint ref_count;
@@ -76,6 +78,14 @@ void hfp_slc_info_init(struct hfp_slc_info *info, guint16 version)
 
 	info->hf_features |= HFP_HF_FEATURE_CODEC_NEGOTIATION;
 
+	if (version < HFP_VERSION_1_7)
+		goto done;
+
+	info->hf_features |= HFP_HF_FEATURE_HF_INDICATORS;
+	memset(info->hf_indicators, 0, sizeof(info->hf_indicators));
+	info->num_hf_indicators = 0;
+	info->hf_indicator_active_map = 0;
+
 done:
 	memset(info->cind_val, 0, sizeof(info->cind_val));
 	memset(info->cind_pos, 0, sizeof(info->cind_pos));
@@ -107,6 +117,104 @@ static void slc_established(struct slc_establish_data *sed)
 	sed->connect_cb(sed->userdata);
 }
 
+static void bind_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
+{
+	struct slc_establish_data *sed = user_data;
+	struct hfp_slc_info *info = sed->info;
+	GAtResultIter iter;
+	int hf_indicator;
+	int enabled;
+	unsigned int i;
+
+	if (!ok)
+		goto error;
+
+	g_at_result_iter_init(&iter, result);
+
+	while (g_at_result_iter_next(&iter, "+BIND:")) {
+		if (!g_at_result_iter_next_number(&iter, &hf_indicator))
+			goto error;
+
+		if (!g_at_result_iter_next_number(&iter, &enabled))
+			goto error;
+
+		ofono_info("AG wants indicator %d %s",
+				hf_indicator, enabled ? "enabled" : "disabled");
+
+		for (i = 0; i < info->num_hf_indicators; i++) {
+			if (info->hf_indicators[i] != hf_indicator)
+				continue;
+
+			info->hf_indicator_active_map |= enabled << i;
+		}
+
+		ofono_info("Active map: %02x", info->hf_indicator_active_map);
+	}
+
+	slc_established(sed);
+	return;
+
+error:
+	slc_failed(sed);
+}
+
+static void bind_support_cb(gboolean ok, GAtResult *result, gpointer user_data)
+{
+	struct slc_establish_data *sed = user_data;
+	struct hfp_slc_info *info = sed->info;
+	GAtResultIter iter;
+	int hf_indicator;
+
+	if (!ok)
+		goto error;
+
+	g_at_result_iter_init(&iter, result);
+
+	if (!g_at_result_iter_next(&iter, "+BIND:"))
+		goto error;
+
+	if (!g_at_result_iter_open_list(&iter))
+		goto error;
+
+	while (g_at_result_iter_next_number(&iter, &hf_indicator)) {
+		if (info->num_hf_indicators >= 20)
+			goto error;
+
+		ofono_info("AG supports the following HF indicator: %d",
+				hf_indicator);
+
+		info->hf_indicators[info->num_hf_indicators] = hf_indicator;
+		info->num_hf_indicators += 1;
+	}
+
+	if (!g_at_result_iter_close_list(&iter))
+		goto error;
+
+	slc_establish_data_ref(sed);
+	g_at_chat_send(info->chat, "AT+BIND?", bind_prefix,
+				bind_query_cb, sed, slc_establish_data_unref);
+
+	return;
+
+error:
+	slc_failed(sed);
+}
+
+static void bind_set_cb(gboolean ok, GAtResult *result, gpointer user_data)
+{
+	struct slc_establish_data *sed = user_data;
+	struct hfp_slc_info *info = sed->info;
+
+	if (!ok) {
+		slc_failed(sed);
+		return;
+	}
+
+	slc_establish_data_ref(sed);
+	g_at_chat_send(info->chat, "AT+BIND=?", bind_prefix,
+				bind_support_cb, sed, slc_establish_data_unref);
+}
+
 static void chld_cb(gboolean ok, GAtResult *result, gpointer user_data)
 {
 	struct slc_establish_data *sed = user_data;
@@ -128,19 +236,19 @@ static void chld_cb(gboolean ok, GAtResult *result, gpointer user_data)
 
 	while (g_at_result_iter_next_unquoted_string(&iter, &str)) {
 		if (!strcmp(str, "0"))
-			ag_mpty_feature |= AG_CHLD_0;
+			ag_mpty_feature |= HFP_AG_CHLD_0;
 		else if (!strcmp(str, "1"))
-			ag_mpty_feature |= AG_CHLD_1;
+			ag_mpty_feature |= HFP_AG_CHLD_1;
 		else if (!strcmp(str, "1x"))
-			ag_mpty_feature |= AG_CHLD_1x;
+			ag_mpty_feature |= HFP_AG_CHLD_1x;
 		else if (!strcmp(str, "2"))
-			ag_mpty_feature |= AG_CHLD_2;
+			ag_mpty_feature |= HFP_AG_CHLD_2;
 		else if (!strcmp(str, "2x"))
-			ag_mpty_feature |= AG_CHLD_2x;
+			ag_mpty_feature |= HFP_AG_CHLD_2x;
 		else if (!strcmp(str, "3"))
-			ag_mpty_feature |= AG_CHLD_3;
+			ag_mpty_feature |= HFP_AG_CHLD_3;
 		else if (!strcmp(str, "4"))
-			ag_mpty_feature |= AG_CHLD_4;
+			ag_mpty_feature |= HFP_AG_CHLD_4;
 	}
 
 	if (!g_at_result_iter_close_list(&iter))
@@ -148,7 +256,14 @@ static void chld_cb(gboolean ok, GAtResult *result, gpointer user_data)
 
 	info->ag_mpty_features = ag_mpty_feature;
 
-	slc_established(sed);
+	if ((info->ag_features & HFP_AG_FEATURE_HF_INDICATORS) &&
+			(info->hf_features & HFP_HF_FEATURE_HF_INDICATORS)) {
+		slc_establish_data_ref(sed);
+		g_at_chat_send(info->chat, "AT+BIND=1", none_prefix,
+				bind_set_cb, sed, slc_establish_data_unref);
+	} else
+		slc_established(sed);
+
 	return;
 
 error:

ofono/drivers/hfpmodem/slc.h

@@ -19,14 +19,6 @@
  *
  */
 
-#define AG_CHLD_0	0x01
-#define AG_CHLD_1	0x02
-#define AG_CHLD_1x	0x04
-#define AG_CHLD_2	0x08
-#define AG_CHLD_2x	0x10
-#define AG_CHLD_3	0x20
-#define AG_CHLD_4	0x40
-
 enum hfp_indicator {
 	HFP_INDICATOR_SERVICE = 0,
 	HFP_INDICATOR_CALL,
@@ -47,6 +39,9 @@ struct hfp_slc_info {
 	unsigned int hf_features;
 	unsigned char cind_pos[HFP_INDICATOR_LAST];
 	unsigned int cind_val[HFP_INDICATOR_LAST];
+	unsigned short hf_indicators[20];
+	unsigned char num_hf_indicators;
+	unsigned int hf_indicator_active_map;
 };
 
 void hfp_slc_info_init(struct hfp_slc_info *info, guint16 version);

ofono/drivers/hfpmodem/voicecall.c

@@ -37,6 +37,7 @@
 #include <ofono/voicecall.h>
 
 #include "common.h"
+#include "hfp.h"
 
 #include "hfpmodem.h"
 #include "slc.h"
@@ -45,6 +46,7 @@
 #define POLL_CLCC_DELAY 50
 #define EXPECT_RELEASE_DELAY 50
 #define CLIP_TIMEOUT 500
+#define EXPECT_RING_DELAY 200
 
 static const char *none_prefix[] = { NULL };
 static const char *clcc_prefix[] = { "+CLCC:", NULL };
@@ -293,7 +295,7 @@ static void clcc_poll_cb(gboolean ok, GAtResult *result, gpointer user_data)
 	 * we won't get indicator update if any of them is released by CHLD=1x.
 	 * So we have to poll it.
 	 */
-	if (num_active > 1 || num_held > 1)
+	if ((num_active > 1 || num_held > 1) && !vd->clcc_source)
 		vd->clcc_source = g_timeout_add(POLL_CLCC_INTERVAL, poll_clcc,
 							vc);
 }
@@ -447,7 +449,7 @@ static void hfp_hold_all_active(struct ofono_voicecall *vc,
 {
 	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
 
-	if (vd->ag_mpty_features & AG_CHLD_2) {
+	if (vd->ag_mpty_features & HFP_AG_CHLD_2) {
 		hfp_template("AT+CHLD=2", vc, generic_cb, 0, cb, data);
 		return;
 	}
@@ -461,7 +463,7 @@ static void hfp_release_all_held(struct ofono_voicecall *vc,
 	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
 	unsigned int held_status = 1 << CALL_STATUS_HELD;
 
-	if (vd->ag_mpty_features & AG_CHLD_0) {
+	if (vd->ag_mpty_features & HFP_AG_CHLD_0) {
 		hfp_template("AT+CHLD=0", vc, generic_cb, held_status,
 				cb, data);
 		return;
@@ -476,7 +478,7 @@ static void hfp_set_udub(struct ofono_voicecall *vc,
 	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
 	unsigned int incoming_or_waiting = 1 << CALL_STATUS_WAITING;
 
-	if (vd->ag_mpty_features & AG_CHLD_0) {
+	if (vd->ag_mpty_features & HFP_AG_CHLD_0) {
 		hfp_template("AT+CHLD=0", vc, generic_cb, incoming_or_waiting,
 				cb, data);
 		return;
@@ -498,6 +500,19 @@ static gboolean expect_release(gpointer user_data)
 	return FALSE;
 }
 
+static gboolean expect_ring(gpointer user_data)
+{
+	struct ofono_voicecall *vc = user_data;
+	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
+
+	g_at_chat_send(vd->chat, "AT+CLCC", clcc_prefix,
+				clcc_poll_cb, vc, NULL);
+
+	vd->clip_source = 0;
+
+	return FALSE;
+}
+
 static void release_all_active_cb(gboolean ok, GAtResult *result,
 							gpointer user_data)
 {
@@ -528,7 +543,7 @@ static void hfp_release_all_active(struct ofono_voicecall *vc,
 {
 	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
 
-	if (vd->ag_mpty_features & AG_CHLD_1) {
+	if (vd->ag_mpty_features & HFP_AG_CHLD_1) {
 		hfp_template("AT+CHLD=1", vc, release_all_active_cb, 0x1, cb,
 									data);
 		return;
@@ -559,7 +574,7 @@ static void hfp_release_specific(struct ofono_voicecall *vc, int id,
 	struct release_id_req *req = NULL;
 	char buf[32];
 
-	if (!(vd->ag_mpty_features & AG_CHLD_1x))
+	if (!(vd->ag_mpty_features & HFP_AG_CHLD_1x))
 		goto error;
 
 	req = g_try_new0(struct release_id_req, 1);
@@ -590,7 +605,7 @@ static void hfp_private_chat(struct ofono_voicecall *vc, int id,
 	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
 	char buf[32];
 
-	if (vd->ag_mpty_features & AG_CHLD_2x) {
+	if (vd->ag_mpty_features & HFP_AG_CHLD_2x) {
 		snprintf(buf, sizeof(buf), "AT+CHLD=2%d", id);
 
 		hfp_template(buf, vc, generic_cb, 0, cb, data);
@@ -606,7 +621,7 @@ static void hfp_create_multiparty(struct ofono_voicecall *vc,
 {
 	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
 
-	if (vd->ag_mpty_features & AG_CHLD_3) {
+	if (vd->ag_mpty_features & HFP_AG_CHLD_3) {
 		hfp_template("AT+CHLD=3", vc, generic_cb, 0, cb, data);
 
 		return;
@@ -625,7 +640,7 @@ static void hfp_transfer(struct ofono_voicecall *vc,
 	 */
 	unsigned int transfer = 0x1 | 0x2 | 0x4 | 0x8;
 
-	if (vd->ag_mpty_features & AG_CHLD_4) {
+	if (vd->ag_mpty_features & HFP_AG_CHLD_4) {
 		hfp_template("AT+CHLD=4", vc, generic_cb, transfer, cb, data);
 
 		return;
@@ -639,8 +654,10 @@ static void hfp_send_dtmf(struct ofono_voicecall *vc, const char *dtmf,
 {
 	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
 	struct change_state_req *req = g_try_new0(struct change_state_req, 1);
+	int len = strlen(dtmf);
 	char *buf;
 	int s;
+	int i;
 
 	if (req == NULL)
 		goto error;
@@ -650,12 +667,15 @@ static void hfp_send_dtmf(struct ofono_voicecall *vc, const char *dtmf,
 	req->data = data;
 	req->affected_types = 0;
 
-	/* strlen("AT+VTS=) = 7 + NULL */
-	buf = g_try_new(char, strlen(dtmf) + 8);
+	/* strlen("AT") + (n-1) * strlen("+VTS=T;") + strlen(+VTS=T) + null */
+	buf = g_try_new(char, len * 7 + 2);
 	if (buf == NULL)
 		goto error;
 
-	sprintf(buf, "AT+VTS=%s", dtmf);
+	s = sprintf(buf, "AT+VTS=%c", dtmf[0]);
+
+	for (i = 1; i < len; i++)
+		s += sprintf(buf + s, ";+VTS=%c", dtmf[i]);
 
 	s = g_at_chat_send(vd->chat, buf, none_prefix,
 				generic_cb, req, g_free);
@@ -751,6 +771,11 @@ static void ring_notify(GAtResult *result, gpointer user_data)
 	struct ofono_call *call;
 	GSList *waiting;
 
+	if (vd->clip_source) {
+		g_source_remove(vd->clip_source);
+		vd->clip_source = 0;
+	}
+
 	/* RING can repeat, ignore if we already have an incoming call */
 	if (g_slist_find_custom(vd->calls,
 				GINT_TO_POINTER(CALL_STATUS_INCOMING),
@@ -975,7 +1000,15 @@ static void ciev_callsetup_notify(struct ofono_voicecall *vc,
 		break;
 
 	case 1:
-		/* Handled in RING/CCWA */
+		/*
+		 * Handled in RING/CCWA most of the time, however sometimes
+		 * the call is answered before the RING unsolicited
+		 * notification has a chance to be generated on the device.
+		 * In this case, we use a failsafe CLCC poll in expect_ring
+		 * callback.
+		 * */
+		vd->clip_source = g_timeout_add(EXPECT_RING_DELAY,
+							expect_ring, vc);
 		break;
 
 	case 2:

ofono/drivers/isimodem/cbs.c

@@ -134,7 +134,9 @@ static void routing_resp_cb(const GIsiMessage *msg, void *data)
 	struct cbs_data *cd = ofono_cbs_get_data(cbs);
 
 	if (!check_resp(msg, SMS_GSM_CB_ROUTING_RESP)) {
-		ofono_cbs_remove(cbs);
+		/* on shutdown, cbs is already being removed */
+		if (g_isi_msg_error(msg) != -ESHUTDOWN)
+			ofono_cbs_remove(cbs);
 		return;
 	}
 

ofono/drivers/ril/ril_call_barring.c

@@ -0,0 +1,284 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_util.h"
+#include "ril_log.h"
+#include "ril_constants.h"
+
+#include "common.h"
+
+/* See 3GPP 27.007 7.4 for possible values */
+#define RIL_MAX_SERVICE_LENGTH 3
+
+/*
+ * ril.h does not state that string count must be given, but that is
+ * still expected by the modem
+ */
+#define RIL_QUERY_STRING_COUNT 4
+#define RIL_SET_STRING_COUNT 5
+#define RIL_SET_PW_STRING_COUNT 3
+
+struct ril_call_barring {
+	GRilIoQueue *q;
+	guint timer_id;
+};
+
+struct ril_call_barring_cbd {
+	struct ril_call_barring *bd;
+	union _ofono_call_barring_cb {
+		ofono_call_barring_query_cb_t query;
+		ofono_call_barring_set_cb_t set;
+		gpointer ptr;
+	} cb;
+	gpointer data;
+};
+
+#define ril_call_barring_cbd_free g_free
+
+static inline struct ril_call_barring *ril_call_barring_get_data(
+					struct ofono_call_barring *b)
+{
+	return ofono_call_barring_get_data(b);
+}
+
+static struct ril_call_barring_cbd *ril_call_barring_cbd_new(
+			struct ril_call_barring *bd, void *cb, void *data)
+{
+	struct ril_call_barring_cbd *cbd;
+
+	cbd = g_new0(struct ril_call_barring_cbd, 1);
+	cbd->bd = bd;
+	cbd->cb.ptr = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+static inline void ril_call_barring_submit_request(struct ril_call_barring *bd,
+	GRilIoRequest* req, guint code, GRilIoChannelResponseFunc response,
+							void *cb, void *data)
+{
+	grilio_queue_send_request_full(bd->q, req, code, response,
+				ril_call_barring_cbd_free,
+				ril_call_barring_cbd_new(bd, cb, data));
+}
+
+static void ril_call_barring_query_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_call_barring_cbd *cbd = user_data;
+	ofono_call_barring_query_cb_t cb = cbd->cb.query;
+
+	if (status == RIL_E_SUCCESS) {
+		int bearer_class = 0;
+		GRilIoParser rilp;
+
+		/*
+		 * Services for which the specified barring facility is active.
+		 * "0" means "disabled for all, -1 if unknown"
+		 */
+		grilio_parser_init(&rilp, data, len);
+		grilio_parser_get_int32(&rilp, NULL); /* count */
+		grilio_parser_get_int32(&rilp, &bearer_class);
+		DBG("Active services: %d", bearer_class);
+		cb(ril_error_ok(&error), bearer_class, cbd->data);
+	} else {
+		ofono_error("Call Barring query error %d", status);
+		cb(ril_error_failure(&error), 0, cbd->data);
+	}
+}
+
+static void ril_call_barring_query(struct ofono_call_barring *b,
+			const char *lock, int cls,
+			ofono_call_barring_query_cb_t cb, void *data)
+{
+	struct ril_call_barring *bd = ofono_call_barring_get_data(b);
+	char cls_textual[RIL_MAX_SERVICE_LENGTH];
+	GRilIoRequest *req = grilio_request_new();
+
+	DBG("lock: %s, services to query: %d", lock, cls);
+
+	/*
+	 * RIL modems do not support 7 as default bearer class. According to
+	 * the 22.030 Annex C: When service code is not given it corresponds to
+	 * "All tele and bearer services"
+	 */
+	if (cls == BEARER_CLASS_DEFAULT) {
+		cls = SERVICE_CLASS_NONE;
+	}
+
+	sprintf(cls_textual, "%d", cls);
+
+	/*
+	 * See 3GPP 27.007 7.4 for parameter descriptions.
+	 * According to ril.h password should be empty string "" when not
+	 * needed, but in reality we only need to give string length as 0
+	 */
+	grilio_request_append_int32(req, RIL_QUERY_STRING_COUNT);
+	grilio_request_append_utf8(req, lock);    /* Facility code */
+	grilio_request_append_int32(req, 0);      /* Password length */
+	grilio_request_append_utf8(req, cls_textual);
+	grilio_request_append_utf8(req, NULL);    /* AID (not yet supported) */
+
+	ril_call_barring_submit_request(bd, req,
+				RIL_REQUEST_QUERY_FACILITY_LOCK,
+				ril_call_barring_query_cb, cb, data);
+	grilio_request_unref(req);
+}
+
+static void ril_call_barring_set_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_call_barring_cbd *cbd = user_data;
+	ofono_call_barring_set_cb_t cb = cbd->cb.set;
+
+	if (status == RIL_E_SUCCESS) {
+		cb(ril_error_ok(&error), cbd->data);
+	} else {
+		ofono_error("Call Barring Set error %d", status);
+		cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static void ril_call_barring_set(struct ofono_call_barring *b,
+		const char *lock, int enable, const char *passwd, int cls,
+		ofono_call_barring_set_cb_t cb, void *data)
+{
+	struct ril_call_barring *bd = ofono_call_barring_get_data(b);
+	char cls_textual[RIL_MAX_SERVICE_LENGTH];
+	GRilIoRequest *req = grilio_request_new();
+
+	DBG("lock: %s, enable: %i, bearer class: %i", lock, enable, cls);
+
+	/*
+	 * RIL modem does not support 7 as default bearer class. According to
+	 * the 22.030 Annex C: When service code is not given it corresponds to
+	 * "All tele and bearer services"
+	 */
+	if (cls == BEARER_CLASS_DEFAULT) {
+		cls = SERVICE_CLASS_NONE;
+	}
+
+	sprintf(cls_textual, "%d", cls);
+
+	/* See 3GPP 27.007 7.4 for parameter descriptions */
+	grilio_request_append_int32(req, RIL_SET_STRING_COUNT);
+	grilio_request_append_utf8(req, lock);  /* Facility code */
+	grilio_request_append_utf8(req, enable ?
+					RIL_FACILITY_LOCK :
+					RIL_FACILITY_UNLOCK);
+	grilio_request_append_utf8(req, passwd);
+	grilio_request_append_utf8(req, cls_textual);
+	grilio_request_append_utf8(req, NULL);  /* AID (not yet supported) */
+
+	ril_call_barring_submit_request(bd, req,
+				RIL_REQUEST_SET_FACILITY_LOCK,
+				ril_call_barring_set_cb, cb, data);
+	grilio_request_unref(req);
+}
+
+static void ril_call_barring_set_passwd_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_call_barring_cbd *cbd = user_data;
+	ofono_call_barring_set_cb_t cb = cbd->cb.set;
+
+	if (status == RIL_E_SUCCESS) {
+		cb(ril_error_ok(&error), cbd->data);
+	} else {
+		ofono_error("Call Barring Set PW error %d", status);
+		cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static void ril_call_barring_set_passwd(struct ofono_call_barring *b,
+		const char *lock, const char *old_passwd,
+		const char *new_passwd, ofono_call_barring_set_cb_t cb,
+		void *data)
+{
+	struct ril_call_barring *bd = ofono_call_barring_get_data(b);
+	GRilIoRequest *req = grilio_request_new();
+
+	DBG("");
+	grilio_request_append_int32(req, RIL_SET_PW_STRING_COUNT);
+	grilio_request_append_utf8(req, lock);            /* Facility code */
+	grilio_request_append_utf8(req, old_passwd);
+	grilio_request_append_utf8(req, new_passwd);
+
+	ril_call_barring_submit_request(bd, req,
+			RIL_REQUEST_CHANGE_BARRING_PASSWORD,
+			ril_call_barring_set_passwd_cb, cb, data);
+	grilio_request_unref(req);
+}
+
+static gboolean ril_call_barring_register(gpointer user_data)
+{
+	struct ofono_call_barring *b = user_data;
+	struct ril_call_barring *bd = ril_call_barring_get_data(b);
+
+	GASSERT(bd->timer_id);
+	bd->timer_id = 0;
+	ofono_call_barring_register(b);
+	return FALSE;
+}
+
+static int ril_call_barring_probe(struct ofono_call_barring *b,
+					unsigned int vendor, void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_call_barring *bd = g_new0(struct ril_call_barring, 1);
+
+	DBG("");
+	bd->q = grilio_queue_new(ril_modem_io(modem));
+	bd->timer_id = g_idle_add(ril_call_barring_register, b);
+	ofono_call_barring_set_data(b, bd);
+	return 0;
+}
+
+static void ril_call_barring_remove(struct ofono_call_barring *b)
+{
+	struct ril_call_barring *bd = ril_call_barring_get_data(b);
+
+	DBG("");
+	ofono_call_barring_set_data(b, NULL);
+
+	if (bd->timer_id > 0) {
+		g_source_remove(bd->timer_id);
+	}
+
+	grilio_queue_cancel_all(bd->q, FALSE);
+	grilio_queue_unref(bd->q);
+	g_free(bd);
+}
+
+const struct ofono_call_barring_driver ril_call_barring_driver = {
+	.name           = RILMODEM_DRIVER,
+	.probe          = ril_call_barring_probe,
+	.remove         = ril_call_barring_remove,
+	.query          = ril_call_barring_query,
+	.set            = ril_call_barring_set,
+	.set_passwd	= ril_call_barring_set_passwd
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_call_forward.c

@@ -0,0 +1,315 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_util.h"
+#include "ril_log.h"
+#include "ril_constants.h"
+
+#include "common.h"
+
+struct ril_call_forward {
+	GRilIoQueue *q;
+	guint timer_id;
+};
+
+enum ril_call_forward_cmd {
+	CF_ACTION_DISABLE,
+	CF_ACTION_ENABLE,
+	CF_ACTION_UNUSED,
+	CF_ACTION_REGISTRATION,
+	CF_ACTION_ERASURE
+};
+
+struct ril_call_forward_cbd {
+	struct ril_call_forward *fd;
+	union _ofono_call_forward_cb {
+		ofono_call_forwarding_query_cb_t query;
+		ofono_call_forwarding_set_cb_t set;
+		gpointer ptr;
+	} cb;
+	gpointer data;
+};
+
+#define ril_call_forward_cbd_free g_free
+
+static inline struct ril_call_forward *ril_call_forward_get_data(
+					struct ofono_call_forwarding *cf)
+{
+	return ofono_call_forwarding_get_data(cf);
+}
+
+static struct ril_call_forward_cbd *ril_call_forward_cbd_new(void *cb,
+								void *data)
+{
+	struct ril_call_forward_cbd *cbd;
+
+	cbd = g_new0(struct ril_call_forward_cbd, 1);
+	cbd->cb.ptr = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+static inline void ril_call_forward_submit_request(struct ril_call_forward *fd,
+	GRilIoRequest* req, guint code, GRilIoChannelResponseFunc response,
+							void *cb, void *data)
+{
+	grilio_queue_send_request_full(fd->q, req, code, response,
+				ril_call_forward_cbd_free,
+				ril_call_forward_cbd_new(cb, data));
+}
+
+static void ril_forward_set_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_call_forward_cbd *cbd = user_data;
+	ofono_call_forwarding_set_cb_t cb = cbd->cb.set;
+
+	if (status == RIL_E_SUCCESS) {
+		cb(ril_error_ok(&error), cbd->data);
+	} else {
+		ofono_error("CF setting failed");
+		cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static void ril_call_forward_registration(struct ofono_call_forwarding *cf,
+		int type, int cls, const struct ofono_phone_number *number,
+		int time, ofono_call_forwarding_set_cb_t cb, void *data)
+{
+	struct ril_call_forward *fd = ril_call_forward_get_data(cf);
+	GRilIoRequest *req = grilio_request_new();
+
+	ofono_info("cf registration");
+	grilio_request_append_int32(req, CF_ACTION_REGISTRATION);
+	grilio_request_append_int32(req, type);
+
+	/*
+	 * Modem seems to respond with error to all queries
+	 * or settings made with bearer class
+	 * BEARER_CLASS_DEFAULT. Design decision: If given
+	 * class is BEARER_CLASS_DEFAULT let's map it to
+	 * BEARER_CLASS_VOICE as per RIL design.
+	 */
+	if (cls == BEARER_CLASS_DEFAULT) {
+		cls = BEARER_CLASS_VOICE;
+	}
+
+	grilio_request_append_int32(req, cls);
+	grilio_request_append_int32(req, number->type);
+	grilio_request_append_utf8(req, number->number);
+	grilio_request_append_int32(req, time);
+
+	ril_call_forward_submit_request(fd, req, RIL_REQUEST_SET_CALL_FORWARD,
+					ril_forward_set_cb, cb, data);
+	grilio_request_unref(req);
+}
+
+static void ril_call_forward_send_cmd(struct ofono_call_forwarding *cf,
+		int type, int cls, ofono_call_forwarding_set_cb_t cb,
+		void *data, int action)
+{
+	struct ril_call_forward *fd = ril_call_forward_get_data(cf);
+	GRilIoRequest *req = grilio_request_new();
+
+	grilio_request_append_int32(req, action);
+	grilio_request_append_int32(req, type);
+
+	/*
+	 * Modem seems to respond with error to all queries
+	 * or settings made with bearer class
+	 * BEARER_CLASS_DEFAULT. Design decision: If given
+	 * class is BEARER_CLASS_DEFAULT let's map it to
+	 * BEARER_CLASS_VOICE as per RIL design.
+	 */
+	if (cls == BEARER_CLASS_DEFAULT) {
+		cls = BEARER_CLASS_VOICE;
+	}
+
+	grilio_request_append_int32(req, cls);          /* Service class */
+
+	/* Following 3 values have no real meaning in erasure
+	 * but apparently RIL expects them so fields need to
+	 * be filled. Otherwise there is no response
+	 */
+	grilio_request_append_int32(req, 0x81);		/* TOA unknown */
+	grilio_request_append_utf8(req, "1234567890");
+	grilio_request_append_int32(req, 60);
+
+	ril_call_forward_submit_request(fd, req, RIL_REQUEST_SET_CALL_FORWARD,
+					ril_forward_set_cb, cb, data);
+	grilio_request_unref(req);
+}
+
+static void ril_call_forward_erasure(struct ofono_call_forwarding *cf,
+	int type, int cls, ofono_call_forwarding_set_cb_t cb, void *data)
+{
+	ofono_info("CF_ACTION_ERASURE");
+	ril_call_forward_send_cmd(cf, type, cls, cb, data, CF_ACTION_ERASURE);
+}
+
+static void ril_call_forward_deactivate(struct ofono_call_forwarding *cf,
+	int type, int cls, ofono_call_forwarding_set_cb_t cb, void *data)
+{
+	ofono_info("CF_ACTION_DISABLE");
+	ril_call_forward_send_cmd(cf, type, cls, cb, data, CF_ACTION_DISABLE);
+}
+
+static void ril_call_forward_activate(struct ofono_call_forwarding *cf,
+	int type, int cls, ofono_call_forwarding_set_cb_t cb, void *data)
+{
+	ofono_info("CF_ACTION_ENABLE");
+	ril_call_forward_send_cmd(cf, type, cls, cb, data, CF_ACTION_ENABLE);
+}
+
+static void ril_call_forward_query_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_call_forward_cbd *cbd = user_data;
+	ofono_call_forwarding_query_cb_t cb = cbd->cb.query;
+
+	if (status == RIL_E_SUCCESS) {
+		struct ofono_call_forwarding_condition *list = NULL;
+		GRilIoParser rilp;
+		int count = 0;
+		int i;
+
+		grilio_parser_init(&rilp, data, len);
+		grilio_parser_get_int32(&rilp, &count);
+
+		list = g_new0(struct ofono_call_forwarding_condition, count);
+		for (i = 0; i < count; i++) {
+			struct ofono_call_forwarding_condition *fw = list + i;
+			char *str;
+
+			grilio_parser_get_int32(&rilp, &fw->status);
+			grilio_parser_get_int32(&rilp, NULL);
+			grilio_parser_get_int32(&rilp, &fw->cls);
+			grilio_parser_get_int32(&rilp, &fw->phone_number.type);
+			str = grilio_parser_get_utf8(&rilp);
+			if (str) {
+				strncpy(fw->phone_number.number, str,
+					OFONO_MAX_PHONE_NUMBER_LENGTH);
+				fw->phone_number.number[
+					OFONO_MAX_PHONE_NUMBER_LENGTH] = 0;
+				g_free(str);
+			}
+			grilio_parser_get_int32(&rilp, &fw->time);
+		}
+
+		cb(ril_error_ok(&error), count, list, cbd->data);
+		g_free(list);
+	} else {
+		ofono_error("CF query failed");
+		cb(ril_error_failure(&error), 0, NULL, cbd->data);
+	}
+}
+
+static void ril_call_forward_query(struct ofono_call_forwarding *cf, int type,
+		int cls, ofono_call_forwarding_query_cb_t cb, void *data)
+{
+	struct ril_call_forward *fd = ril_call_forward_get_data(cf);
+	GRilIoRequest *req = grilio_request_new();
+
+	ofono_info("cf query");
+	grilio_request_append_int32(req, 2);
+	grilio_request_append_int32(req, type);
+
+	/*
+	 * Modem seems to respond with error to all queries
+	 * or settings made with bearer class
+	 * BEARER_CLASS_DEFAULT. Design decision: If given
+	 * class is BEARER_CLASS_DEFAULT let's map it to
+	 * SERVICE_CLASS_NONE as per RIL design.
+	 */
+	if (cls == BEARER_CLASS_DEFAULT) {
+		cls = SERVICE_CLASS_NONE;
+	}
+
+	grilio_request_append_int32(req, cls);
+
+	/* Following 3 values have no real meaning in query
+	 * but apparently RIL expects them so fields need to
+	 * be filled. Otherwise there is no response
+	 */
+	grilio_request_append_int32(req, 0x81);	        /* TOA unknown */
+	grilio_request_append_utf8(req, "1234567890");
+	grilio_request_append_int32(req, 0);
+
+	ril_call_forward_submit_request(fd, req,
+					RIL_REQUEST_QUERY_CALL_FORWARD_STATUS,
+					ril_call_forward_query_cb, cb, data);
+	grilio_request_unref(req);
+}
+
+static gboolean ril_call_forward_register(gpointer user_data)
+{
+	struct ofono_call_forwarding *cf = user_data;
+	struct ril_call_forward *fd = ril_call_forward_get_data(cf);
+
+	fd->timer_id = 0;
+	ofono_call_forwarding_register(cf);
+	return FALSE;
+}
+
+static int ril_call_forward_probe(struct ofono_call_forwarding *cf,
+					unsigned int vendor, void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_call_forward *fd = g_try_new0(struct ril_call_forward, 1);
+
+	DBG("");
+	fd->q = grilio_queue_new(ril_modem_io(modem));
+	fd->timer_id = g_idle_add(ril_call_forward_register, cf);
+	ofono_call_forwarding_set_data(cf, fd);
+	return 0;
+}
+
+static void ril_call_forward_remove(struct ofono_call_forwarding *cf)
+{
+	struct ril_call_forward *fd = ril_call_forward_get_data(cf);
+
+	DBG("");
+	ofono_call_forwarding_set_data(cf, NULL);
+
+	if (fd->timer_id > 0) {
+		g_source_remove(fd->timer_id);
+	}
+
+	grilio_queue_cancel_all(fd->q, FALSE);
+	grilio_queue_unref(fd->q);
+	g_free(fd);
+}
+
+const struct ofono_call_forwarding_driver ril_call_forwarding_driver = {
+	.name           = RILMODEM_DRIVER,
+	.probe          = ril_call_forward_probe,
+	.remove         = ril_call_forward_remove,
+	.erasure        = ril_call_forward_erasure,
+	.deactivation	= ril_call_forward_deactivate,
+	.query          = ril_call_forward_query,
+	.registration   = ril_call_forward_registration,
+	.activation     = ril_call_forward_activate
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_call_settings.c

@@ -0,0 +1,309 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_util.h"
+#include "ril_log.h"
+#include "ril_constants.h"
+
+#include "common.h"
+
+struct ril_call_settings {
+	GRilIoQueue *q;
+	guint timer_id;
+};
+
+struct ril_call_settings_cbd {
+	union _ofono_call_settings_cb {
+		ofono_call_settings_status_cb_t status;
+		ofono_call_settings_set_cb_t set;
+		ofono_call_settings_clir_cb_t clir;
+		gpointer ptr;
+	} cb;
+	gpointer data;
+};
+
+#define ril_call_settings_cbd_free g_free
+
+static inline struct ril_call_settings *ril_call_settings_get_data(
+					struct ofono_call_settings *b)
+{
+	return ofono_call_settings_get_data(b);
+}
+
+static struct ril_call_settings_cbd *ril_call_settings_cbd_new(void *cb,
+								void *data)
+{
+	struct ril_call_settings_cbd *cbd;
+
+	cbd = g_new0(struct ril_call_settings_cbd, 1);
+	cbd->cb.ptr = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+static inline void ril_call_settings_submit_req(struct ril_call_settings *sd,
+	GRilIoRequest* req, guint code, GRilIoChannelResponseFunc response,
+							void *cb, void *data)
+{
+	grilio_queue_send_request_full(sd->q, req, code, response,
+				ril_call_settings_cbd_free,
+				ril_call_settings_cbd_new(cb, data));
+}
+
+static void ril_call_settings_clip_query_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_call_settings_cbd *cbd = user_data;
+	ofono_call_settings_status_cb_t cb = cbd->cb.status;
+
+	if (status == RIL_E_SUCCESS) {
+		GRilIoParser rilp;
+		int res = 0;
+
+		/* data length of the response */
+		grilio_parser_init(&rilp, data, len);
+		if (grilio_parser_get_int32(&rilp, &res) && res > 0) {
+			grilio_parser_get_int32(&rilp, &res);
+		}
+
+		cb(ril_error_ok(&error), res, cbd->data);
+	} else {
+		cb(ril_error_failure(&error), -1, cbd->data);
+	}
+}
+
+static void ril_call_settings_set_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_call_settings_cbd *cbd = user_data;
+	ofono_call_settings_set_cb_t cb = cbd->cb.set;
+
+	if (status == RIL_E_SUCCESS) {
+		cb(ril_error_ok(&error), cbd->data);
+	} else {
+		cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static void ril_call_settings_cw_set(struct ofono_call_settings *cs, int mode,
+			int cls, ofono_call_settings_set_cb_t cb, void *data)
+{
+	struct ril_call_settings *sd = ril_call_settings_get_data(cs);
+	GRilIoRequest *req = grilio_request_sized_new(12);
+
+	grilio_request_append_int32(req, 2);    /* Number of params */
+	grilio_request_append_int32(req, mode); /* on/off */
+
+	/* Modem seems to respond with error to all queries
+	 * or settings made with bearer class
+	 * BEARER_CLASS_DEFAULT. Design decision: If given
+	 * class is BEARER_CLASS_DEFAULT let's map it to
+	 * SERVICE_CLASS_VOICE effectively making it the
+	 * default bearer. This in line with API which is
+	 * contains only voice anyways.
+	 */
+	if (cls == BEARER_CLASS_DEFAULT) {
+		cls = BEARER_CLASS_VOICE;
+	}
+
+	grilio_request_append_int32(req, cls);  /* Service class */
+
+	ril_call_settings_submit_req(sd, req, RIL_REQUEST_SET_CALL_WAITING,
+					ril_call_settings_set_cb, cb, data);
+	grilio_request_unref(req);
+}
+
+static void ril_call_settings_cw_query_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_call_settings_cbd *cbd = user_data;
+	ofono_call_settings_status_cb_t cb = cbd->cb.status;
+
+	if (status == RIL_E_SUCCESS) {
+		GRilIoParser rilp;
+		int res = 0;
+		int sv = 0;
+
+		grilio_parser_init(&rilp, data, len);
+
+		/* first value in int[] is len so let's skip that */
+		grilio_parser_get_int32(&rilp, NULL);
+
+		/* status of call waiting service, disabled is returned only if
+		 * service is not active for any service class */
+		grilio_parser_get_int32(&rilp, &res);
+		DBG("CW enabled/disabled: %d", res);
+
+		if (res > 0) {
+			/* services for which call waiting is enabled,
+			   27.007 7.12 */
+			grilio_parser_get_int32(&rilp, &sv);
+			DBG("CW enabled for: %d", sv);
+		}
+
+		cb(ril_error_ok(&error), sv, cbd->data);
+	} else {
+		cb(ril_error_failure(&error), -1, cbd->data);
+	}
+}
+
+static void ril_call_settings_cw_query(struct ofono_call_settings *cs, int cls,
+				ofono_call_settings_status_cb_t cb, void *data)
+{
+	struct ril_call_settings *sd = ril_call_settings_get_data(cs);
+	GRilIoRequest *req = grilio_request_sized_new(8);
+
+	grilio_request_append_int32(req, 1);		/* Number of params */
+
+	/*
+	 * RILD expects service class to be 0 as certain carriers can reject
+	 * the query with specific service class
+	 */
+	grilio_request_append_int32(req, 0);
+
+	ril_call_settings_submit_req(sd, req, RIL_REQUEST_QUERY_CALL_WAITING,
+				ril_call_settings_cw_query_cb, cb, data);
+	grilio_request_unref(req);
+}
+
+static void ril_call_settings_clip_query(struct ofono_call_settings *cs,
+			ofono_call_settings_status_cb_t cb, void *data)
+{
+	struct ril_call_settings *sd = ril_call_settings_get_data(cs);
+
+	ril_call_settings_submit_req(sd, NULL, RIL_REQUEST_QUERY_CLIP,
+				ril_call_settings_clip_query_cb, cb, data);
+}
+
+static void ril_call_settings_clir_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_call_settings_cbd *cbd = user_data;
+	ofono_call_settings_clir_cb_t cb = cbd->cb.clir;
+
+	if (status == RIL_E_SUCCESS) {
+		GRilIoParser rilp;
+		int override = -1, network = -1;
+
+		grilio_parser_init(&rilp, data, len);
+		/*first value in int[] is len so let's skip that*/
+		grilio_parser_get_int32(&rilp, NULL);
+		/* Set HideCallerId property from network */
+		grilio_parser_get_int32(&rilp, &override);
+		/* CallingLineRestriction indicates the state of
+		the CLIR supplementary service in the network */
+		grilio_parser_get_int32(&rilp, &network);
+
+		cb(ril_error_ok(&error), override, network, cbd->data);
+	} else {
+		cb(ril_error_failure(&error), -1, -1, cbd->data);
+	}
+}
+
+static void ril_call_settings_clir_query(struct ofono_call_settings *cs,
+			ofono_call_settings_clir_cb_t cb, void *data)
+{
+	struct ril_call_settings *sd = ril_call_settings_get_data(cs);
+
+	ril_call_settings_submit_req(sd, NULL, RIL_REQUEST_GET_CLIR,
+					ril_call_settings_clir_cb, cb, data);
+}
+
+static void ril_call_settings_clir_set(struct ofono_call_settings *cs,
+			int mode, ofono_call_settings_set_cb_t cb, void *data)
+{
+	struct ril_call_settings *sd = ril_call_settings_get_data(cs);
+	GRilIoRequest *req = grilio_request_sized_new(8);
+
+	grilio_request_append_int32(req, 1); /* Number of params */
+	grilio_request_append_int32(req, mode); /* for outgoing calls */
+
+	ril_call_settings_submit_req(sd, req, RIL_REQUEST_SET_CLIR,
+					ril_call_settings_set_cb, cb, data);
+	grilio_request_unref(req);
+}
+
+static gboolean ril_call_settings_register(gpointer user_data)
+{
+	struct ofono_call_settings *cs = user_data;
+	struct ril_call_settings *sd = ril_call_settings_get_data(cs);
+
+	DBG("");
+	GASSERT(sd->timer_id);
+	sd->timer_id = 0;
+	ofono_call_settings_register(cs);
+
+	/* Single-shot */
+	return FALSE;
+}
+
+static int ril_call_settings_probe(struct ofono_call_settings *cs,
+					unsigned int vendor, void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_call_settings *sd = g_try_new0(struct ril_call_settings, 1);
+
+	DBG("");
+	sd->q = grilio_queue_new(ril_modem_io(modem));
+	sd->timer_id = g_idle_add(ril_call_settings_register, cs);
+	ofono_call_settings_set_data(cs, sd);
+	return 0;
+}
+
+static void ril_call_settings_remove(struct ofono_call_settings *cs)
+{
+	struct ril_call_settings *sd = ril_call_settings_get_data(cs);
+
+	DBG("");
+	ofono_call_settings_set_data(cs, NULL);
+
+	if (sd->timer_id > 0) {
+		g_source_remove(sd->timer_id);
+        }
+
+	grilio_queue_cancel_all(sd->q, FALSE);
+	grilio_queue_unref(sd->q);
+	g_free(sd);
+}
+
+const struct ofono_call_settings_driver ril_call_settings_driver = {
+	.name           = RILMODEM_DRIVER,
+	.probe          = ril_call_settings_probe,
+	.remove         = ril_call_settings_remove,
+	.clip_query	= ril_call_settings_clip_query,
+	.cw_query       = ril_call_settings_cw_query,
+	.cw_set         = ril_call_settings_cw_set,
+	.clir_query     = ril_call_settings_clir_query,
+	.clir_set       = ril_call_settings_clir_set
+
+	/*
+	 * Not supported in RIL API
+	 * .colp_query     = ril_call_settings_colp_query,
+	 * .colr_query     = ril_call_settings_colr_query
+	 */
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_call_volume.c

@@ -0,0 +1,151 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_util.h"
+#include "ril_log.h"
+#include "ril_constants.h"
+
+struct ril_call_volume {
+	struct ofono_call_volume *v;
+	GRilIoQueue *q;
+	guint timer_id;
+};
+
+struct ril_call_volume_req {
+	ofono_call_volume_cb_t cb;
+	gpointer data;
+};
+
+static inline struct ril_call_volume *ril_call_volume_get_data(
+					struct ofono_call_volume *v)
+{
+	return ofono_call_volume_get_data(v);
+}
+
+static void ril_call_volume_mute_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_call_volume_req *cbd = user_data;
+	ofono_call_volume_cb_t cb = cbd->cb;
+
+	if (status == RIL_E_SUCCESS) {
+		cb(ril_error_ok(&error), cbd->data);
+	} else {
+		ofono_error("Could not set the ril mute state");
+		cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static void ril_call_volume_mute(struct ofono_call_volume *v, int muted,
+				ofono_call_volume_cb_t cb, void *data)
+{
+	struct ril_call_volume *vd = ril_call_volume_get_data(v);
+	struct ril_call_volume_req *cbd;
+	GRilIoRequest *req = grilio_request_sized_new(8);
+
+	cbd = g_new(struct ril_call_volume_req, 1);
+	cbd->cb = cb;
+	cbd->data = data;
+
+	DBG("%d", muted);
+	grilio_request_append_int32(req, 1);
+	grilio_request_append_int32(req, muted);
+	grilio_queue_send_request_full(vd->q, req, RIL_REQUEST_SET_MUTE,
+				 ril_call_volume_mute_cb, g_free, cbd);
+	grilio_request_unref(req);
+}
+
+static void ril_call_volume_query_mute_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_call_volume *vd = user_data;
+
+	if (status == RIL_E_SUCCESS) {
+		int muted = 0;
+		GRilIoParser rilp;
+
+		grilio_parser_init(&rilp, data, len);
+		grilio_parser_get_int32(&rilp, NULL); /* Array length */
+		grilio_parser_get_int32(&rilp, &muted);
+		DBG("{%d}", muted);
+		ofono_call_volume_set_muted(vd->v, muted);
+	} else {
+		ofono_error("Could not retrive the ril mute state");
+	}
+}
+
+static gboolean ril_call_volume_register(gpointer user_data)
+{
+	struct ril_call_volume *vd = user_data;
+
+	DBG("");
+	GASSERT(vd->timer_id);
+	vd->timer_id = 0;
+	ofono_call_volume_register(vd->v);
+
+	/* Probe the mute state */
+	grilio_queue_send_request_full(vd->q, NULL,
+		RIL_REQUEST_GET_MUTE, ril_call_volume_query_mute_cb, NULL, vd);
+
+	/* This makes the timeout a single-shot */
+	return FALSE;
+}
+
+static int ril_call_volume_probe(struct ofono_call_volume *v,
+				unsigned int vendor, void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_call_volume *vd = g_new0(struct ril_call_volume, 1);
+
+	DBG("");
+	vd->v = v;
+	vd->q = grilio_queue_new(ril_modem_io(modem));
+	vd->timer_id = g_idle_add(ril_call_volume_register, vd);
+	ofono_call_volume_set_data(v, vd);
+	return 0;
+}
+
+static void ril_call_volume_remove(struct ofono_call_volume *v)
+{
+	struct ril_call_volume *vd = ril_call_volume_get_data(v);
+
+	DBG("");
+	ofono_call_volume_set_data(v, NULL);
+
+	if (vd->timer_id) {
+		g_source_remove(vd->timer_id);
+	}
+
+	grilio_queue_cancel_all(vd->q, FALSE);
+	grilio_queue_unref(vd->q);
+	g_free(vd);
+}
+
+const struct ofono_call_volume_driver ril_call_volume_driver = {
+	.name       = RILMODEM_DRIVER,
+	.probe      = ril_call_volume_probe,
+	.remove     = ril_call_volume_remove,
+	.mute       = ril_call_volume_mute,
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_cbs.c

@@ -0,0 +1,119 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_util.h"
+#include "ril_log.h"
+#include "ril_constants.h"
+
+struct ril_cbs {
+	struct ofono_cbs *cbs;
+	GRilIoChannel *io;
+	guint timer_id;
+	gulong event_id;
+};
+
+static void ril_set_topics(struct ofono_cbs *cbs, const char *topics,
+				ofono_cbs_set_cb_t cb, void *data)
+{
+	struct ofono_error error;
+	cb(ril_error_ok(&error), data);
+}
+
+static void ril_clear_topics(struct ofono_cbs *cbs,
+				ofono_cbs_set_cb_t cb, void *data)
+{
+	struct ofono_error error;
+	cb(ril_error_ok(&error), data);
+}
+
+static void ril_cbs_notify(GRilIoChannel *io, guint code,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_cbs *cd = user_data;
+	GRilIoParser rilp;
+	char* pdu;
+
+	GASSERT(code == RIL_UNSOL_ON_USSD);
+	grilio_parser_init(&rilp, data, len);
+	pdu = grilio_parser_get_utf8(&rilp);
+	DBG("%s", pdu);
+	if (pdu) {
+		ofono_cbs_notify(cd->cbs, (const guchar *)pdu, strlen(pdu));
+		g_free(pdu);
+	}
+}
+
+static gboolean ril_cbs_register(gpointer user_data)
+{
+	struct ril_cbs *cd = user_data;
+
+	DBG("");
+	GASSERT(cd->timer_id);
+	cd->timer_id = 0;
+	ofono_cbs_register(cd->cbs);
+
+	cd->event_id = grilio_channel_add_unsol_event_handler(cd->io,
+		ril_cbs_notify, RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS, cd);
+
+	/* Single-shot */
+	return FALSE;
+}
+
+static int ril_cbs_probe(struct ofono_cbs *cbs, unsigned int vendor,
+								void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_cbs *cd = g_try_new0(struct ril_cbs, 1);
+
+	DBG("");
+	cd->cbs = cbs;
+	cd->io = grilio_channel_ref(ril_modem_io(modem));
+	cd->timer_id = g_idle_add(ril_cbs_register, cd);
+	ofono_cbs_set_data(cbs, cd);
+	return 0;
+}
+
+static void ril_cbs_remove(struct ofono_cbs *cbs)
+{
+	struct ril_cbs *cd = ofono_cbs_get_data(cbs);
+
+	DBG("");
+	ofono_cbs_set_data(cbs, NULL);
+
+	if (cd->timer_id > 0) {
+		g_source_remove(cd->timer_id);
+	}
+
+	grilio_channel_remove_handler(cd->io, cd->event_id);
+	grilio_channel_unref(cd->io);
+	g_free(cd);
+}
+
+const struct ofono_cbs_driver ril_cbs_driver = {
+	.name           = RILMODEM_DRIVER,
+	.probe          = ril_cbs_probe,
+	.remove         = ril_cbs_remove,
+	.set_topics     = ril_set_topics,
+	.clear_topics   = ril_clear_topics
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_constants.h

@@ -0,0 +1,447 @@
+/*
+ *
+ *  RIL constants adopted from AOSP's header:
+ *
+ *  /hardware/ril/reference_ril/ril.h
+ *
+ *  Copyright (C) 2013 Canonical Ltd.
+ *  Copyright (C) 2013-2016 Jolla 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.
+ */
+
+#ifndef __RIL_CONSTANTS_H
+#define __RIL_CONSTANTS_H 1
+
+/* Error Codes */
+#define RIL_E_SUCCESS 0
+#define RIL_E_RADIO_NOT_AVAILABLE 1
+#define RIL_E_GENERIC_FAILURE 2
+#define RIL_E_PASSWORD_INCORRECT 3
+#define RIL_E_SIM_PIN2 4
+#define RIL_E_SIM_PUK2 5
+#define RIL_E_REQUEST_NOT_SUPPORTED 6
+#define RIL_E_CANCELLED 7
+#define RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL 8
+#define RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW 9
+#define RIL_E_SMS_SEND_FAIL_RETRY 10
+#define RIL_E_SIM_ABSENT 11
+#define RIL_E_SUBSCRIPTION_NOT_AVAILABLE 12
+#define RIL_E_MODE_NOT_SUPPORTED 13
+#define RIL_E_FDN_CHECK_FAILURE 14
+#define RIL_E_ILLEGAL_SIM_OR_ME 15
+#define RIL_E_UNUSED 16
+#define RIL_E_DIAL_MODIFIED_TO_USSD 17
+#define RIL_E_DIAL_MODIFIED_TO_SS 18
+#define RIL_E_DIAL_MODIFIED_TO_DIAL 19
+#define RIL_E_USSD_MODIFIED_TO_DIAL 20
+#define RIL_E_USSD_MODIFIED_TO_SS 21
+#define RIL_E_USSD_MODIFIED_TO_USSD 22
+#define RIL_E_SS_MODIFIED_TO_DIAL 23
+#define RIL_E_SS_MODIFIED_TO_USSD 24
+#define RIL_E_SS_MODIFIED_TO_SS 25
+#define RIL_E_SUBSCRIPTION_NOT_SUPPORTED 26
+#define RIL_E_MISSING_RESOURCE 27
+#define RIL_E_NO_SUCH_ELEMENT 28
+#define RIL_E_INVALID_PARAMETER 29
+
+/* call states */
+enum ril_call_state {
+	RIL_CALL_ACTIVE   = 0,
+	RIL_CALL_HOLDING  = 1,
+	RIL_CALL_DIALING  = 2,
+	RIL_CALL_ALERTING = 3,
+	RIL_CALL_INCOMING = 4,
+	RIL_CALL_WAITING  = 5
+};
+
+/* Radio state */
+enum ril_radio_state {
+	RADIO_STATE_OFF                   = 0,
+	RADIO_STATE_UNAVAILABLE           = 1,
+	RADIO_STATE_SIM_NOT_READY         = 2,
+	RADIO_STATE_SIM_LOCKED_OR_ABSENT  = 3,
+	RADIO_STATE_SIM_READY             = 4,
+	RADIO_STATE_RUIM_NOT_READY        = 5,
+	RADIO_STATE_RUIM_READY            = 6,
+	RADIO_STATE_RUIM_LOCKED_OR_ABSENT = 7,
+	RADIO_STATE_NV_NOT_READY          = 8,
+	RADIO_STATE_NV_READY              = 9,
+	RADIO_STATE_ON                    = 10
+};
+
+/* Preferred network types */
+enum ril_pref_net_type {
+	PREF_NET_TYPE_GSM_WCDMA                 = 0,
+	PREF_NET_TYPE_GSM_ONLY                  = 1,
+	PREF_NET_TYPE_WCDMA                     = 2,
+	PREF_NET_TYPE_GSM_WCDMA_AUTO            = 3,
+	PREF_NET_TYPE_CDMA_EVDO_AUTO            = 4,
+	PREF_NET_TYPE_CDMA_ONLY                 = 5,
+	PREF_NET_TYPE_EVDO_ONLY                 = 6,
+	PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO  = 7,
+	PREF_NET_TYPE_LTE_CDMA_EVDO             = 8,
+	PREF_NET_TYPE_LTE_GSM_WCDMA             = 9,
+	PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA   = 10,
+	PREF_NET_TYPE_LTE_ONLY                  = 11,
+	PREF_NET_TYPE_LTE_WCDMA                 = 12
+};
+
+/* Radio technologies */
+enum ril_radio_tech {
+	RADIO_TECH_UNKNOWN  = 0,
+	RADIO_TECH_GPRS     = 1,
+	RADIO_TECH_EDGE     = 2,
+	RADIO_TECH_UMTS     = 3,
+	RADIO_TECH_IS95A    = 4,
+	RADIO_TECH_IS95B    = 5,
+	RADIO_TECH_1xRTT    = 6,
+	RADIO_TECH_EVDO_0   = 7,
+	RADIO_TECH_EVDO_A   = 8,
+	RADIO_TECH_HSDPA    = 9,
+	RADIO_TECH_HSUPA    = 10,
+	RADIO_TECH_HSPA     = 11,
+	RADIO_TECH_EVDO_B   = 12,
+	RADIO_TECH_EHRPD    = 13,
+	RADIO_TECH_LTE      = 14,
+	RADIO_TECH_HSPAP    = 15,
+	RADIO_TECH_GSM      = 16,
+	RADIO_TECH_TD_SCDMA = 17,
+	RADIO_TECH_IWLAN    = 18
+};
+
+/* See RIL_REQUEST_LAST_CALL_FAIL_CAUSE */
+#define CALL_FAIL_UNOBTAINABLE_NUMBER 1
+#define CALL_FAIL_NORMAL 16
+#define CALL_FAIL_BUSY 17
+#define CALL_FAIL_CONGESTION 34
+#define CALL_FAIL_ACM_LIMIT_EXCEEDED 68
+#define CALL_FAIL_CALL_BARRED 240
+#define CALL_FAIL_FDN_BLOCKED 241
+#define CALL_FAIL_IMSI_UNKNOWN_IN_VLR 242
+#define CALL_FAIL_IMEI_NOT_ACCEPTED 243
+#define CALL_FAIL_DIAL_MODIFIED_TO_USSD 244
+#define CALL_FAIL_DIAL_MODIFIED_TO_SS 245
+#define CALL_FAIL_DIAL_MODIFIED_TO_DIAL 246
+#define CALL_FAIL_CDMA_LOCKED_UNTIL_POWER_CYCLE 1000
+#define CALL_FAIL_CDMA_DROP 1001
+#define CALL_FAIL_CDMA_INTERCEPT 1002
+#define CALL_FAIL_CDMA_REORDER 1003
+#define CALL_FAIL_CDMA_SO_REJECT 1004
+#define CALL_FAIL_CDMA_RETRY_ORDER 1005
+#define CALL_FAIL_CDMA_ACCESS_FAILURE 1006
+#define CALL_FAIL_CDMA_PREEMPTED 1007
+#define CALL_FAIL_CDMA_NOT_EMERGENCY 1008
+#define CALL_FAIL_CDMA_ACCESS_BLOCKED 1009
+#define CALL_FAIL_ERROR_UNSPECIFIED 0xffff
+
+/* Not defined in ril.h but valid 3GPP specific cause values
+ * for call control. See 3GPP TS 24.008 Annex H. */
+#define CALL_FAIL_NO_ROUTE_TO_DESTINATION 3
+#define CALL_FAIL_CHANNEL_UNACCEPTABLE 6
+#define CALL_FAIL_OPERATOR_DETERMINED_BARRING 8
+#define CALL_FAIL_NO_USER_RESPONDING 18
+#define CALL_FAIL_USER_ALERTING_NO_ANSWER 19
+#define CALL_FAIL_CALL_REJECTED 21
+#define CALL_FAIL_NUMBER_CHANGED 22
+#define CALL_FAIL_ANONYMOUS_CALL_REJECTION 24
+#define CALL_FAIL_PRE_EMPTION 25
+#define CALL_FAIL_DESTINATION_OUT_OF_ORDER 27
+#define CALL_FAIL_INCOMPLETE_NUMBER 28
+#define CALL_FAIL_FACILITY_REJECTED 29
+#define CALL_FAIL_NORMAL_UNSPECIFIED 31
+
+/* see RIL_REQUEST_DEACTIVATE_DATA_CALL parameter */
+#define RIL_DEACTIVATE_DATA_CALL_NO_REASON 0
+#define RIL_DEACTIVATE_DATA_CALL_RADIO_SHUTDOWN 1
+
+/* See RIL_REQUEST_SETUP_DATA_CALL */
+
+#define RIL_DATA_PROFILE_DEFAULT 0
+#define RIL_DATA_PROFILE_TETHERED 1
+#define RIL_DATA_PROFILE_IMS 2
+#define RIL_DATA_PROFILE_FOTA 3           /* FOTA = Firmware Over the Air */
+#define RIL_DATA_PROFILE_CBS 4
+#define RIL_DATA_PROFILE_OEM_BASE 1000    /* Start of OEM-specific profiles */
+
+#define RIL_AUTH_NONE 0
+#define RIL_AUTH_PAP 1
+#define RIL_AUTH_CHAP 2
+#define RIL_AUTH_BOTH 3
+
+#define RIL_CARD_MAX_APPS 8
+
+/* SIM card states */
+enum ril_card_state {
+	RIL_CARDSTATE_UNKNOWN = -1,
+	RIL_CARDSTATE_ABSENT  = 0,
+	RIL_CARDSTATE_PRESENT = 1,
+	RIL_CARDSTATE_ERROR   = 2
+};
+
+/* SIM personalization substates */
+enum ril_perso_substate {
+	RIL_PERSOSUBSTATE_UNKNOWN                   = 0,
+	RIL_PERSOSUBSTATE_IN_PROGRESS               = 1,
+	RIL_PERSOSUBSTATE_READY                     = 2,
+	RIL_PERSOSUBSTATE_SIM_NETWORK               = 3,
+	RIL_PERSOSUBSTATE_SIM_NETWORK_SUBSET        = 4,
+	RIL_PERSOSUBSTATE_SIM_CORPORATE             = 5,
+	RIL_PERSOSUBSTATE_SIM_SERVICE_PROVIDER      = 6,
+	RIL_PERSOSUBSTATE_SIM_SIM                   = 7,
+	RIL_PERSOSUBSTATE_SIM_NETWORK_PUK           = 8,
+	RIL_PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK    = 9,
+	RIL_PERSOSUBSTATE_SIM_CORPORATE_PUK         = 10,
+	RIL_PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK  = 11,
+	RIL_PERSOSUBSTATE_SIM_SIM_PUK               = 12,
+	RIL_PERSOSUBSTATE_RUIM_NETWORK1             = 13,
+	RIL_PERSOSUBSTATE_RUIM_NETWORK2             = 14,
+	RIL_PERSOSUBSTATE_RUIM_HRPD                 = 15,
+	RIL_PERSOSUBSTATE_RUIM_CORPORATE            = 16,
+	RIL_PERSOSUBSTATE_RUIM_SERVICE_PROVIDER     = 17,
+	RIL_PERSOSUBSTATE_RUIM_RUIM                 = 18,
+	RIL_PERSOSUBSTATE_RUIM_NETWORK1_PUK         = 19,
+	RIL_PERSOSUBSTATE_RUIM_NETWORK2_PUK         = 20,
+	RIL_PERSOSUBSTATE_RUIM_HRPD_PUK             = 21,
+	RIL_PERSOSUBSTATE_RUIM_CORPORATE_PUK        = 22,
+	RIL_PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK = 23,
+	RIL_PERSOSUBSTATE_RUIM_RUIM_PUK             = 24
+};
+
+/* SIM - App states */
+enum ril_app_state {
+	RIL_APPSTATE_ILLEGAL            = -1,
+	RIL_APPSTATE_UNKNOWN            = 0,
+	RIL_APPSTATE_DETECTED           = 1,
+	RIL_APPSTATE_PIN                = 2,
+	RIL_APPSTATE_PUK                = 3,
+	RIL_APPSTATE_SUBSCRIPTION_PERSO = 4,
+	RIL_APPSTATE_READY              = 5
+};
+
+/* SIM - PIN states */
+enum ril_pin_state {
+	RIL_PINSTATE_UNKNOWN              = 0,
+	RIL_PINSTATE_ENABLED_NOT_VERIFIED = 1,
+	RIL_PINSTATE_ENABLED_VERIFIED     = 2,
+	RIL_PINSTATE_DISABLED             = 3,
+	RIL_PINSTATE_ENABLED_BLOCKED      = 4,
+	RIL_PINSTATE_ENABLED_PERM_BLOCKED = 5
+};
+
+/* SIM - App types */
+enum ril_app_type {
+	RIL_APPTYPE_UNKNOWN = 0,
+	RIL_APPTYPE_SIM     = 1,
+	RIL_APPTYPE_USIM    = 2,
+	RIL_APPTYPE_RUIM    = 3,
+	RIL_APPTYPE_CSIM    = 4,
+	RIL_APPTYPE_ISIM    = 5
+};
+
+/* RIL Request Messages */
+#define RIL_REQUEST_GET_SIM_STATUS 1
+#define RIL_REQUEST_ENTER_SIM_PIN 2
+#define RIL_REQUEST_ENTER_SIM_PUK 3
+#define RIL_REQUEST_ENTER_SIM_PIN2 4
+#define RIL_REQUEST_ENTER_SIM_PUK2 5
+#define RIL_REQUEST_CHANGE_SIM_PIN 6
+#define RIL_REQUEST_CHANGE_SIM_PIN2 7
+#define RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION 8
+#define RIL_REQUEST_GET_CURRENT_CALLS 9
+#define RIL_REQUEST_DIAL 10
+#define RIL_REQUEST_GET_IMSI 11
+#define RIL_REQUEST_HANGUP 12
+#define RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND 13
+#define RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND 14
+#define RIL_REQUEST_SWITCH_HOLDING_AND_ACTIVE 15
+#define RIL_REQUEST_CONFERENCE 16
+#define RIL_REQUEST_UDUB 17
+#define RIL_REQUEST_LAST_CALL_FAIL_CAUSE 18
+#define RIL_REQUEST_SIGNAL_STRENGTH 19
+#define RIL_REQUEST_VOICE_REGISTRATION_STATE 20
+#define RIL_REQUEST_DATA_REGISTRATION_STATE 21
+#define RIL_REQUEST_OPERATOR 22
+#define RIL_REQUEST_RADIO_POWER 23
+#define RIL_REQUEST_DTMF 24
+#define RIL_REQUEST_SEND_SMS 25
+#define RIL_REQUEST_SEND_SMS_EXPECT_MORE 26
+#define RIL_REQUEST_SETUP_DATA_CALL 27
+#define RIL_REQUEST_SIM_IO 28
+#define RIL_REQUEST_SEND_USSD 29
+#define RIL_REQUEST_CANCEL_USSD 30
+#define RIL_REQUEST_GET_CLIR 31
+#define RIL_REQUEST_SET_CLIR 32
+#define RIL_REQUEST_QUERY_CALL_FORWARD_STATUS 33
+#define RIL_REQUEST_SET_CALL_FORWARD 34
+#define RIL_REQUEST_QUERY_CALL_WAITING 35
+#define RIL_REQUEST_SET_CALL_WAITING 36
+#define RIL_REQUEST_SMS_ACKNOWLEDGE  37
+#define RIL_REQUEST_GET_IMEI 38
+#define RIL_REQUEST_GET_IMEISV 39
+#define RIL_REQUEST_ANSWER 40
+#define RIL_REQUEST_DEACTIVATE_DATA_CALL 41
+#define RIL_REQUEST_QUERY_FACILITY_LOCK 42
+#define RIL_REQUEST_SET_FACILITY_LOCK 43
+#define RIL_REQUEST_CHANGE_BARRING_PASSWORD 44
+#define RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE 45
+#define RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC 46
+#define RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL 47
+#define RIL_REQUEST_QUERY_AVAILABLE_NETWORKS 48
+#define RIL_REQUEST_DTMF_START 49
+#define RIL_REQUEST_DTMF_STOP 50
+#define RIL_REQUEST_BASEBAND_VERSION 51
+#define RIL_REQUEST_SEPARATE_CONNECTION 52
+#define RIL_REQUEST_SET_MUTE 53
+#define RIL_REQUEST_GET_MUTE 54
+#define RIL_REQUEST_QUERY_CLIP 55
+#define RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE 56
+#define RIL_REQUEST_DATA_CALL_LIST 57
+#define RIL_REQUEST_RESET_RADIO 58
+#define RIL_REQUEST_OEM_HOOK_RAW 59
+#define RIL_REQUEST_OEM_HOOK_STRINGS 60
+#define RIL_REQUEST_SCREEN_STATE 61
+#define RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION 62
+#define RIL_REQUEST_WRITE_SMS_TO_SIM 63
+#define RIL_REQUEST_DELETE_SMS_ON_SIM 64
+#define RIL_REQUEST_SET_BAND_MODE 65
+#define RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE 66
+#define RIL_REQUEST_STK_GET_PROFILE 67
+#define RIL_REQUEST_STK_SET_PROFILE 68
+#define RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND 69
+#define RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE 70
+#define RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM 71
+#define RIL_REQUEST_EXPLICIT_CALL_TRANSFER 72
+#define RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE 73
+#define RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE 74
+#define RIL_REQUEST_GET_NEIGHBORING_CELL_IDS 75
+#define RIL_REQUEST_SET_LOCATION_UPDATES 76
+#define RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE 77
+#define RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE 78
+#define RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE 79
+#define RIL_REQUEST_SET_TTY_MODE 80
+#define RIL_REQUEST_QUERY_TTY_MODE 81
+#define RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE 82
+#define RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE 83
+#define RIL_REQUEST_CDMA_FLASH 84
+#define RIL_REQUEST_CDMA_BURST_DTMF 85
+#define RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY 86
+#define RIL_REQUEST_CDMA_SEND_SMS 87
+#define RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE 88
+#define RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG 89
+#define RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG 90
+#define RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION 91
+#define RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG 92
+#define RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG 93
+#define RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION 94
+#define RIL_REQUEST_CDMA_SUBSCRIPTION 95
+#define RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM 96
+#define RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM 97
+#define RIL_REQUEST_DEVICE_IDENTITY 98
+#define RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE 99
+#define RIL_REQUEST_GET_SMSC_ADDRESS 100
+#define RIL_REQUEST_SET_SMSC_ADDRESS 101
+#define RIL_REQUEST_REPORT_SMS_MEMORY_STATUS 102
+#define RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING 103
+#define RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE 104
+#define RIL_REQUEST_ISIM_AUTHENTICATION 105
+#define RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU 106
+#define RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS 107
+#define RIL_REQUEST_VOICE_RADIO_TECH 108
+#define RIL_REQUEST_GET_CELL_INFO_LIST 109
+#define RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE 110
+#define RIL_REQUEST_SET_INITIAL_ATTACH_APN 111
+#define RIL_REQUEST_IMS_REGISTRATION_STATE 112
+#define RIL_REQUEST_IMS_SEND_SMS 113
+#define RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC 114
+#define RIL_REQUEST_SIM_OPEN_CHANNEL 115
+#define RIL_REQUEST_SIM_CLOSE_CHANNEL 116
+#define RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL 117
+#define RIL_REQUEST_NV_READ_ITEM 118
+#define RIL_REQUEST_NV_WRITE_ITEM 119
+#define RIL_REQUEST_NV_WRITE_CDMA_PRL 120
+#define RIL_REQUEST_NV_RESET_CONFIG 121
+/* SET_UICC_SUBSCRIPTION was 115 in v9 and 122 in v10 and later */
+#define RIL_REQUEST_V9_SET_UICC_SUBSCRIPTION  115
+#define RIL_REQUEST_SET_UICC_SUBSCRIPTION  122
+#define RIL_REQUEST_ALLOW_DATA  123
+#define RIL_REQUEST_GET_HARDWARE_CONFIG 124
+#define RIL_REQUEST_SIM_AUTHENTICATION 125
+#define RIL_REQUEST_GET_DC_RT_INFO 126
+#define RIL_REQUEST_SET_DC_RT_INFO_RATE 127
+#define RIL_REQUEST_SET_DATA_PROFILE 128
+#define RIL_REQUEST_SHUTDOWN 129
+#define RIL_REQUEST_GET_RADIO_CAPABILITY 130
+#define RIL_REQUEST_SET_RADIO_CAPABILITY 131
+
+/* RIL Unsolicited Messages */
+#define RIL_UNSOL_RESPONSE_BASE 1000
+#define RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED 1000
+#define RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED 1001
+#define RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED 1002
+#define RIL_UNSOL_RESPONSE_NEW_SMS 1003
+#define RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT 1004
+#define RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM 1005
+#define RIL_UNSOL_ON_USSD 1006
+#define RIL_UNSOL_ON_USSD_REQUEST 1007
+#define RIL_UNSOL_NITZ_TIME_RECEIVED  1008
+#define RIL_UNSOL_SIGNAL_STRENGTH  1009
+#define RIL_UNSOL_DATA_CALL_LIST_CHANGED 1010
+#define RIL_UNSOL_SUPP_SVC_NOTIFICATION 1011
+#define RIL_UNSOL_STK_SESSION_END 1012
+#define RIL_UNSOL_STK_PROACTIVE_COMMAND 1013
+#define RIL_UNSOL_STK_EVENT_NOTIFY 1014
+#define RIL_UNSOL_STK_CALL_SETUP 1015
+#define RIL_UNSOL_SIM_SMS_STORAGE_FULL 1016
+#define RIL_UNSOL_SIM_REFRESH 1017
+#define RIL_UNSOL_CALL_RING 1018
+#define RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED 1019
+#define RIL_UNSOL_RESPONSE_CDMA_NEW_SMS 1020
+#define RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS 1021
+#define RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL 1022
+#define RIL_UNSOL_RESTRICTED_STATE_CHANGED 1023
+#define RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE 1024
+#define RIL_UNSOL_CDMA_CALL_WAITING 1025
+#define RIL_UNSOL_CDMA_OTA_PROVISION_STATUS 1026
+#define RIL_UNSOL_CDMA_INFO_REC 1027
+#define RIL_UNSOL_OEM_HOOK_RAW 1028
+#define RIL_UNSOL_RINGBACK_TONE 1029
+#define RIL_UNSOL_RESEND_INCALL_MUTE 1030
+#define RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED 1031
+#define RIL_UNSOL_CDMA_PRL_CHANGED 1032
+#define RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE 1033
+#define RIL_UNSOL_RIL_CONNECTED 1034
+#define RIL_UNSOL_VOICE_RADIO_TECH_CHANGED 1035
+#define RIL_UNSOL_CELL_INFO_LIST 1036
+#define RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED 1037
+#define RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED 1038
+#define RIL_UNSOL_SRVCC_STATE_NOTIFY 1039
+#define RIL_UNSOL_HARDWARE_CONFIG_CHANGED 1040
+#define RIL_UNSOL_DC_RT_INFO_CHANGED 1041
+#define RIL_UNSOL_RADIO_CAPABILITY 1042
+#define RIL_UNSOL_ON_SS 1043
+#define RIL_UNSOL_STK_CC_ALPHA_NOTIFY 1044
+
+/* Suplementary services Service class*/
+#define SERVICE_CLASS_NONE 0
+
+/* RIL_FACILITY_LOCK parameters */
+#define RIL_FACILITY_UNLOCK "0"
+#define RIL_FACILITY_LOCK "1"
+
+#endif /*__RIL_CONSTANTS_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_data.c

@@ -0,0 +1,313 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2016 Jolla 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.
+ */
+
+#include "ril_data.h"
+#include "ril_log.h"
+
+#include <grilio_queue.h>
+#include <grilio_request.h>
+
+typedef GObjectClass RilDataClass;
+typedef struct ril_data RilData;
+
+struct ril_data_manager {
+	gint ref_count;
+	struct ril_data *selected;
+	guint pending_id;
+	GSList *data_list;
+};
+
+struct ril_data {
+	GObject object;
+	GRilIoQueue *q;
+	const char *log_prefix;
+	char *custom_log_prefix;
+	struct ril_data_manager *dm;
+	gboolean allowed;
+};
+
+enum ril_data_signal {
+	SIGNAL_ALLOW_CHANGED,
+	SIGNAL_COUNT
+};
+
+#define SIGNAL_ALLOW_CHANGED_NAME    "ril-data-allow-changed"
+
+static guint ril_data_signals[SIGNAL_COUNT] = { 0 };
+
+G_DEFINE_TYPE(RilData, ril_data, G_TYPE_OBJECT)
+#define RIL_DATA_TYPE (ril_data_get_type())
+#define RIL_DATA(obj) (G_TYPE_CHECK_INSTANCE_CAST(obj, RIL_DATA_TYPE,RilData))
+
+static void ril_data_manager_check(struct ril_data_manager *self);
+
+/*==========================================================================*
+ * ril_data
+ *==========================================================================*/
+
+gulong ril_data_add_allow_changed_handler(struct ril_data *self,
+						ril_data_cb_t cb, void *arg)
+{
+	return (G_LIKELY(self) && G_LIKELY(cb)) ? g_signal_connect(self,
+		SIGNAL_ALLOW_CHANGED_NAME, G_CALLBACK(cb), arg) : 0;
+}
+
+void ril_data_remove_handler(struct ril_data *self, gulong id)
+{
+	if (G_LIKELY(self) && G_LIKELY(id)) {
+		g_signal_handler_disconnect(self, id);
+	}
+}
+
+struct ril_data *ril_data_new(struct ril_data_manager *dm, GRilIoChannel *io)
+{
+	GASSERT(dm);
+	if (G_LIKELY(dm)) {
+		struct ril_data *self = g_object_new(RIL_DATA_TYPE, NULL);
+		self->q = grilio_queue_new(io);
+		self->dm = ril_data_manager_ref(dm);
+		dm->data_list = g_slist_append(dm->data_list, self);
+		return self;
+	}
+	return NULL;
+}
+
+struct ril_data *ril_data_ref(struct ril_data *self)
+{
+	if (G_LIKELY(self)) {
+		g_object_ref(RIL_DATA(self));
+		return self;
+	} else {
+		return NULL;
+	}
+}
+
+void ril_data_unref(struct ril_data *self)
+{
+	if (G_LIKELY(self)) {
+		g_object_unref(RIL_DATA(self));
+	}
+}
+
+G_INLINE_FUNC void ril_data_signal(struct ril_data *self)
+{
+	g_signal_emit(self, ril_data_signals[SIGNAL_ALLOW_CHANGED], 0);
+}
+
+void ril_data_allow(struct ril_data *self, gboolean allow)
+{
+	if (G_LIKELY(self)) {
+		struct ril_data_manager *dm = self->dm;
+		DBG("%s%s", self->log_prefix, allow ? "yes" : "no");
+		if (allow) {
+			if (!self->allowed) {
+				self->allowed = TRUE;
+				ril_data_manager_check(dm);
+			}
+		} else {
+			if (self->allowed) {
+				self->allowed = FALSE;
+				if (dm->selected == self) {
+					ril_data_manager_check(dm);
+				}
+			}
+		}
+	}
+}
+
+gboolean ril_data_allowed(struct ril_data *self)
+{
+	return G_LIKELY(self) && self->allowed && self->dm->selected == self;
+}
+
+void ril_data_set_name(struct ril_data *self, const char *name)
+{
+	if (G_LIKELY(self)) {
+		g_free(self->custom_log_prefix);
+		if (name) {
+			self->custom_log_prefix = g_strconcat(name, " ", NULL);
+			self->log_prefix = self->custom_log_prefix;
+		} else {
+			self->custom_log_prefix = NULL;
+			self->log_prefix = "";
+		}
+	}
+}
+
+static void ril_data_init(struct ril_data *self)
+{
+	self->log_prefix = "";
+}
+
+static void ril_data_dispose(GObject *object)
+{
+	struct ril_data *self = RIL_DATA(object);
+	struct ril_data_manager	*dm = self->dm;
+
+	dm->data_list = g_slist_remove(dm->data_list, self);
+	grilio_queue_cancel_all(self->q, FALSE);
+	ril_data_manager_check(dm);
+	G_OBJECT_CLASS(ril_data_parent_class)->dispose(object);
+}
+
+static void ril_data_finalize(GObject *object)
+{
+	struct ril_data *self = RIL_DATA(object);
+
+	g_free(self->custom_log_prefix);
+	grilio_queue_unref(self->q);
+	ril_data_manager_unref(self->dm);
+	G_OBJECT_CLASS(ril_data_parent_class)->finalize(object);
+}
+
+static void ril_data_class_init(RilDataClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS(klass);
+
+	object_class->dispose = ril_data_dispose;
+	object_class->finalize = ril_data_finalize;
+	ril_data_signals[SIGNAL_ALLOW_CHANGED] =
+		g_signal_new(SIGNAL_ALLOW_CHANGED_NAME,
+			G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
+			0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+}
+
+/*==========================================================================*
+ * ril_data_manager
+ *==========================================================================*/
+
+struct ril_data_manager *ril_data_manager_new()
+{
+	struct ril_data_manager *self = g_new0(struct ril_data_manager, 1);
+	self->ref_count = 1;
+	return self;
+}
+
+struct ril_data_manager *ril_data_manager_ref(struct ril_data_manager *self)
+{
+	if (self) {
+		GASSERT(self->ref_count > 0);
+		g_atomic_int_inc(&self->ref_count);
+	}
+	return self;
+}
+
+void ril_data_manager_unref(struct ril_data_manager *self)
+{
+	if (self) {
+		GASSERT(self->ref_count > 0);
+		if (g_atomic_int_dec_and_test(&self->ref_count)) {
+			GASSERT(!self->selected);
+			g_free(self);
+		}
+	}
+}
+
+static void ril_data_manager_allow_data_cb(GRilIoChannel *io, int ril_status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_data_manager *self = user_data;
+
+	GASSERT(self->selected);
+	GASSERT(self->pending_id);
+	self->pending_id = 0;
+
+	if (ril_status == RIL_E_SUCCESS) {
+		DBG("%sselected", self->selected->log_prefix);
+	} else {
+		DBG("%srequest failed", self->selected->log_prefix);
+	}
+}
+
+static struct ril_data *ril_data_manager_pick(struct ril_data_manager *self)
+{
+	GSList *list = self->data_list;
+	while (list) {
+		struct ril_data *data = list->data;
+		if (data->allowed) {
+			return data;
+		}
+		list = list->next;
+	}
+	return NULL;
+}
+
+static GRilIoRequest *ril_data_allow_req(gboolean allow)
+{
+	GRilIoRequest *req = grilio_request_sized_new(8);
+
+	grilio_request_append_int32(req, 1);
+	grilio_request_append_int32(req, allow != FALSE);
+	return req;
+}
+
+static void ril_data_manager_check(struct ril_data_manager *self)
+{
+	struct ril_data *data = ril_data_manager_pick(self);
+
+	if (data) {
+		if (self->selected != data) {
+			GRilIoRequest *req = ril_data_allow_req(TRUE);
+			struct ril_data *prev = self->selected;
+
+			/* Cancel pending request, if any */
+			GASSERT(prev || !self->pending_id);
+			if (prev) {
+				grilio_queue_cancel_request(prev->q,
+						self->pending_id, FALSE);
+			}
+
+			/*
+			 * Submit the RIL request. Note that with
+			 * some older RILs this request will never
+			 * get completed (no reply from rild will
+			 * ever come).
+			 */
+			grilio_request_set_retry(req, RIL_RETRY_MS, -1);
+			self->pending_id =
+				grilio_queue_send_request_full(data->q, req,
+					RIL_REQUEST_ALLOW_DATA,
+					ril_data_manager_allow_data_cb,
+					NULL, self);
+			grilio_request_unref(req);
+
+			DBG("%srequested", data->log_prefix);
+			self->selected = data;
+			if (prev) {
+				ril_data_signal(prev);
+			}
+			ril_data_signal(data);
+		}
+	} else {
+		if (self->selected) {
+			struct ril_data *prev = self->selected;
+			if (self->pending_id) {
+				grilio_queue_cancel_request(prev->q,
+						self->pending_id, FALSE);
+				self->pending_id = 0;
+			}
+			self->selected = NULL;
+			ril_data_signal(prev);
+		}
+	}
+}
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_data.h

@@ -0,0 +1,46 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2016 Jolla 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.
+ */
+
+#ifndef RIL_DATA_H
+#define RIL_DATA_H
+
+#include "ril_types.h"
+
+struct ril_data_manager;
+struct ril_data_manager *ril_data_manager_new(void);
+struct ril_data_manager *ril_data_manager_ref(struct ril_data_manager *dm);
+void ril_data_manager_unref(struct ril_data_manager *dm);
+
+struct ril_data *ril_data_new(struct ril_data_manager *dm, GRilIoChannel *io);
+struct ril_data *ril_data_ref(struct ril_data *data);
+void ril_data_unref(struct ril_data *data);
+void ril_data_set_name(struct ril_data *data, const char *name);
+void ril_data_allow(struct ril_data *data, gboolean allow);
+gboolean ril_data_allowed(struct ril_data *data);
+
+typedef void (*ril_data_cb_t)(struct ril_data *data, void *arg);
+gulong ril_data_add_allow_changed_handler(struct ril_data *data,
+					ril_data_cb_t cb, void *arg);
+void ril_data_remove_handler(struct ril_data *data, gulong id);
+
+#endif /* RIL_DATA_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_devinfo.c

@@ -0,0 +1,193 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_util.h"
+#include "ril_log.h"
+
+/*
+ * TODO: No public RIL api to query manufacturer or model.
+ * Check where to get, could /system/build.prop be updated to have good values?
+ */
+
+struct ril_devinfo {
+	struct ofono_devinfo *info;
+	GRilIoQueue *q;
+	guint register_id;
+	guint imei_id;
+	char *imei;
+};
+
+struct ril_devinfo_cbd {
+	struct ril_devinfo *di;
+	ofono_devinfo_query_cb_t cb;
+	gpointer data;
+};
+
+#define ril_devinfo_cbd_free g_free
+
+static inline struct ril_devinfo *ril_devinfo_get_data(
+					struct ofono_devinfo *info)
+{
+	return ofono_devinfo_get_data(info);
+}
+
+struct ril_devinfo_cbd *ril_devinfo_cbd_new(struct ril_devinfo *di,
+				ofono_devinfo_query_cb_t cb, void *data)
+{
+	struct ril_devinfo_cbd *cbd = g_new0(struct ril_devinfo_cbd, 1);
+
+	cbd->di = di;
+	cbd->cb = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+static void ril_devinfo_query_unsupported(struct ofono_devinfo *info,
+			ofono_devinfo_query_cb_t cb, void *data)
+{
+	struct ofono_error error;
+	cb(ril_error_failure(&error), "", data);
+}
+
+static void ril_devinfo_query_cb(GRilIoChannel *io, int status,
+			const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_devinfo_cbd *cbd = user_data;
+
+	if (status == RIL_E_SUCCESS) {
+		char *res;
+		GRilIoParser rilp;
+		grilio_parser_init(&rilp, data, len);
+		res = grilio_parser_get_utf8(&rilp);
+		DBG("%s", res);
+		cbd->cb(ril_error_ok(&error), res ? res : "", cbd->data);
+		g_free(res);
+	} else {
+		cbd->cb(ril_error_failure(&error), NULL, cbd->data);
+	}
+}
+
+static void ril_devinfo_query_revision(struct ofono_devinfo *info,
+				ofono_devinfo_query_cb_t cb, void *data)
+{
+	struct ril_devinfo *di = ril_devinfo_get_data(info);
+
+	DBG("");
+	grilio_queue_send_request_full(di->q, NULL, RIL_REQUEST_BASEBAND_VERSION,
+				ril_devinfo_query_cb, ril_devinfo_cbd_free,
+				ril_devinfo_cbd_new(di, cb, data));
+}
+
+static gboolean ril_devinfo_query_serial_cb(void *user_data)
+{
+	struct ril_devinfo_cbd *cbd = user_data;
+	struct ril_devinfo *di = cbd->di;
+	struct ofono_error error;
+
+	GASSERT(di->imei_id);
+	di->imei_id = 0;
+
+	cbd->cb(ril_error_ok(&error), di->imei, cbd->data);
+	return FALSE;
+}
+
+static void ril_devinfo_query_serial(struct ofono_devinfo *info,
+				ofono_devinfo_query_cb_t cb,
+				void *data)
+{
+	struct ril_devinfo *di = ril_devinfo_get_data(info);
+
+	GASSERT(!di->imei_id);
+	if (di->imei_id) {
+		g_source_remove(di->imei_id);
+		di->imei_id = 0;
+	}
+
+	DBG("%s", di->imei);
+	di->imei_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
+					ril_devinfo_query_serial_cb,
+					ril_devinfo_cbd_new(di, cb, data),
+					ril_devinfo_cbd_free);
+}
+
+static gboolean ril_devinfo_register(gpointer user_data)
+{
+	struct ril_devinfo *di = user_data;
+
+	DBG("");
+	di->register_id = 0;
+	ofono_devinfo_register(di->info);
+
+	/* This makes the timeout a single-shot */
+	return FALSE;
+}
+
+static int ril_devinfo_probe(struct ofono_devinfo *info, unsigned int vendor,
+				void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_devinfo *di = g_new0(struct ril_devinfo, 1);
+
+	DBG("%s %s %p", ril_modem_get_path(modem), modem->imei, di);
+	GASSERT(modem->imei);
+	di->q = grilio_queue_new(ril_modem_io(modem));
+	di->info = info;
+	di->imei = g_strdup(modem->imei);
+
+	di->register_id = g_idle_add(ril_devinfo_register, di);
+	ofono_devinfo_set_data(info, di);
+	return 0;
+}
+
+static void ril_devinfo_remove(struct ofono_devinfo *info)
+{
+	struct ril_devinfo *di = ril_devinfo_get_data(info);
+
+	DBG("%p", di);
+	ofono_devinfo_set_data(info, NULL);
+
+	if (di->register_id > 0) {
+		g_source_remove(di->register_id);
+	}
+
+	if (di->imei_id > 0) {
+		g_source_remove(di->imei_id);
+	}
+
+	grilio_queue_cancel_all(di->q, FALSE);
+	grilio_queue_unref(di->q);
+	g_free(di->imei);
+	g_free(di);
+}
+
+const struct ofono_devinfo_driver ril_devinfo_driver = {
+	.name                   = RILMODEM_DRIVER,
+	.probe                  = ril_devinfo_probe,
+	.remove                 = ril_devinfo_remove,
+	.query_manufacturer     = ril_devinfo_query_unsupported,
+	.query_model            = ril_devinfo_query_unsupported,
+	.query_revision         = ril_devinfo_query_revision,
+	.query_serial           = ril_devinfo_query_serial
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_gprs.c

@@ -0,0 +1,283 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_network.h"
+#include "ril_data.h"
+#include "ril_util.h"
+#include "ril_log.h"
+
+#include "common.h"
+
+/*
+ * This module is the ofono_gprs_driver implementation for rilmodem.
+ *
+ * Notes:
+ *
+ * 1. ofono_gprs_suspend/resume() are not used by this module, as
+ *    the concept of suspended GPRS is not exposed by RILD.
+ *
+ * 2. ofono_gprs_bearer_notify() is never called as RILD does not
+ *    expose an unsolicited event equivalent to +CPSB ( see 27.007
+ *    7.29 ), and the tech values returned by REQUEST_DATA/VOICE
+ *    _REGISTRATION requests do not match the values defined for
+ *    <AcT> in the +CPSB definition.  Note, the values returned by
+ *    the *REGISTRATION commands are aligned with those defined by
+ *    +CREG ( see 27.003 7.2 ).
+ */
+
+struct ril_gprs {
+	struct ofono_gprs *gprs;
+	struct ril_modem *md;
+	struct ril_data *data;
+	struct ril_network *network;
+	GRilIoChannel *io;
+	GRilIoQueue *q;
+	gboolean attached;
+	int max_cids;
+	enum network_registration_status registration_status;
+	guint register_id;
+	gulong network_event_id;
+	gulong data_event_id;
+	guint set_attached_id;
+};
+
+struct ril_gprs_cbd {
+	struct ril_gprs *gd;
+	ofono_gprs_cb_t cb;
+	gpointer data;
+};
+
+#define ril_gprs_cbd_free g_free
+
+static struct ril_gprs *ril_gprs_get_data(struct ofono_gprs *ofono)
+{
+	return ofono ? ofono_gprs_get_data(ofono) : NULL;
+}
+
+static struct ril_gprs_cbd *ril_gprs_cbd_new(struct ril_gprs *gd,
+						ofono_gprs_cb_t cb, void *data)
+{
+	struct ril_gprs_cbd *cbd = g_new0(struct ril_gprs_cbd, 1);
+
+	cbd->gd = gd;
+	cbd->cb = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+static enum network_registration_status ril_gprs_fix_registration_status(
+		struct ril_gprs *gd, enum network_registration_status status)
+{
+	if (!ril_data_allowed(gd->data)) {
+		return NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
+	} else {
+		/* TODO: need a way to make sure that SPDI information has
+		 * already been read from the SIM (i.e. sim_spdi_read_cb in
+		 * network.c has been called) */
+		struct ofono_netreg *netreg = ril_modem_ofono_netreg(gd->md);
+		return ril_netreg_check_if_really_roaming(netreg, status);
+	}
+}
+
+static void ril_gprs_data_update_registration_state(struct ril_gprs *gd)
+{
+	const enum network_registration_status status =
+		ril_gprs_fix_registration_status(gd, gd->network->data.status);
+
+	if (gd->registration_status != status) {
+		ofono_info("data reg changed %d -> %d (%s), attached %d",
+				gd->registration_status, status,
+				registration_status_to_string(status),
+				gd->attached);
+		gd->registration_status = status;
+		ofono_gprs_status_notify(gd->gprs, gd->registration_status);
+	}
+}
+
+static void ril_gprs_check_data_allowed(struct ril_gprs *gd)
+{
+	DBG("%s %d %d", ril_modem_get_path(gd->md), ril_data_allowed(gd->data),
+								gd->attached);
+	if (!ril_data_allowed(gd->data) && gd->attached) {
+		gd->attached = FALSE;
+		if (gd->gprs) {
+			ofono_gprs_detached_notify(gd->gprs);
+		}
+	}
+
+	ril_gprs_data_update_registration_state(gd);
+}
+
+static gboolean ril_gprs_set_attached_cb(gpointer user_data)
+{
+	struct ofono_error error;
+	struct ril_gprs_cbd *cbd = user_data;
+	struct ril_gprs *gd = cbd->gd;
+
+	GASSERT(gd->set_attached_id);
+	gd->set_attached_id = 0;
+	ril_gprs_check_data_allowed(gd);
+	cbd->cb(ril_error_ok(&error), cbd->data);
+	return FALSE;
+}
+
+static void ril_gprs_set_attached(struct ofono_gprs *gprs, int attached,
+					ofono_gprs_cb_t cb, void *data)
+{
+	struct ril_gprs *gd = ril_gprs_get_data(gprs);
+
+	if (ril_data_allowed(gd->data) || !attached) {
+		DBG("%s attached: %d", ril_modem_get_path(gd->md), attached);
+		if (gd->set_attached_id) {
+			g_source_remove(gd->set_attached_id);
+		}
+		gd->attached = attached;
+		gd->set_attached_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
+					ril_gprs_set_attached_cb,
+					ril_gprs_cbd_new(gd, cb, data),
+					ril_gprs_cbd_free);
+	} else {
+		struct ofono_error error;
+		DBG("%s not allowed to attach", ril_modem_get_path(gd->md));
+		cb(ril_error_failure(&error), data);
+	}
+}
+
+static void ril_gprs_allow_data_changed(struct ril_data *data, void *user_data)
+{
+	struct ril_gprs *gd = user_data;
+
+	GASSERT(gd->data == data);
+	DBG("%s %d", ril_modem_get_path(gd->md), ril_data_allowed(data));
+	if (!gd->set_attached_id) {
+		ril_gprs_check_data_allowed(gd);
+	}
+}
+
+static void ril_gprs_data_registration_state_changed(struct ril_network *net,
+							void *user_data)
+{
+	struct ril_gprs *gd = user_data;
+	const struct ril_registration_state *data = &net->data;
+
+	GASSERT(gd->network == net);
+	if (data->max_calls > gd->max_cids) {
+		DBG("Setting max cids to %d", data->max_calls);
+		gd->max_cids = data->max_calls;
+		ofono_gprs_set_cid_range(gd->gprs, 1, gd->max_cids);
+	}
+
+	ril_gprs_data_update_registration_state(gd);
+}
+
+static void ril_gprs_registration_status(struct ofono_gprs *gprs,
+				ofono_gprs_status_cb_t cb, void *data)
+{
+	struct ril_gprs *gd = ril_gprs_get_data(gprs);
+	struct ofono_error error;
+	const enum network_registration_status status = gd->attached ?
+		gd->registration_status :
+		NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
+
+
+	DBG("%d (%s)", status, registration_status_to_string(status));
+	cb(ril_error_ok(&error), status, data);
+}
+
+static gboolean ril_gprs_register(gpointer user_data)
+{
+	struct ril_gprs *gd = user_data;
+
+	gd->register_id = 0;
+	gd->network_event_id = ril_network_add_data_state_changed_handler(
+		gd->network, ril_gprs_data_registration_state_changed, gd);
+	gd->data_event_id = ril_data_add_allow_changed_handler(gd->data,
+		ril_gprs_allow_data_changed, gd);
+	gd->registration_status = ril_gprs_fix_registration_status(gd,
+						gd->network->data.status);
+
+	gd->max_cids = gd->network->data.max_calls;
+	if (gd->max_cids > 0) {
+		DBG("Setting max cids to %d", gd->max_cids);
+		ofono_gprs_set_cid_range(gd->gprs, 1, gd->max_cids);
+	}
+
+	ofono_gprs_register(gd->gprs);
+	return FALSE;
+}
+
+static int ril_gprs_probe(struct ofono_gprs *gprs, unsigned int vendor,
+								void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_gprs *gd = g_new0(struct ril_gprs, 1);
+
+	DBG("%s", ril_modem_get_path(modem));
+	gd->md = modem;
+	gd->io = grilio_channel_ref(ril_modem_io(modem));
+        gd->q = grilio_queue_new(gd->io);
+	gd->data = ril_data_ref(modem->data);
+	gd->network = ril_network_ref(modem->network);
+	gd->gprs = gprs;
+	ofono_gprs_set_data(gprs, gd);
+
+	/* ofono crashes if we register right away */
+	gd->register_id = g_idle_add(ril_gprs_register, gd);
+	return 0;
+}
+
+static void ril_gprs_remove(struct ofono_gprs *gprs)
+{
+	struct ril_gprs *gd = ril_gprs_get_data(gprs);
+
+	DBG("%s", ril_modem_get_path(gd->md));
+	ofono_gprs_set_data(gprs, NULL);
+
+	if (gd->set_attached_id) {
+		g_source_remove(gd->set_attached_id);
+	}
+
+	if (gd->register_id) {
+		g_source_remove(gd->register_id);
+	}
+
+	ril_network_remove_handler(gd->network, gd->network_event_id);
+	ril_network_unref(gd->network);
+
+	ril_data_remove_handler(gd->data, gd->data_event_id);
+	ril_data_unref(gd->data);
+
+	grilio_channel_unref(gd->io);
+	grilio_queue_cancel_all(gd->q, FALSE);
+	grilio_queue_unref(gd->q);
+	g_free(gd);
+}
+
+const struct ofono_gprs_driver ril_gprs_driver = {
+	.name                   = RILMODEM_DRIVER,
+	.probe                  = ril_gprs_probe,
+	.remove                 = ril_gprs_remove,
+	.set_attached           = ril_gprs_set_attached,
+	.attached_status        = ril_gprs_registration_status,
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_gprs_context.c

@@ -0,0 +1,972 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_network.h"
+#include "ril_util.h"
+#include "ril_log.h"
+
+#include <gutil_strv.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "common.h"
+
+#define PROTO_IP_STR "IP"
+#define PROTO_IPV6_STR "IPV6"
+#define PROTO_IPV4V6_STR "IPV4V6"
+
+#define MIN_DATA_CALL_LIST_SIZE 8
+#define MIN_DATA_CALL_REPLY_SIZE 36
+
+#define SETUP_DATA_CALL_PARAMS 7
+#define DATA_PROFILE_DEFAULT_STR "0"
+#define DEACTIVATE_DATA_CALL_PARAMS 2
+
+#define CTX_ID_NONE ((unsigned int)(-1))
+
+enum data_call_state {
+	DATA_CALL_INACTIVE,
+	DATA_CALL_LINK_DOWN,
+	DATA_CALL_ACTIVE,
+};
+
+enum ril_gprs_context_state {
+	STATE_IDLE,
+	STATE_ACTIVATING,
+	STATE_DEACTIVATING,
+	STATE_ACTIVE,
+};
+
+struct ril_gprs_context {
+	struct ofono_gprs_context *gc;
+	struct ril_modem *modem;
+	struct ril_network *network;
+	GRilIoChannel *io;
+	GRilIoQueue *q;
+	guint active_ctx_cid;
+	enum ril_gprs_context_state state;
+	gulong regid;
+	struct ril_gprs_context_data_call *active_call;
+	struct ril_gprs_context_deactivate_req *deactivate_req;
+};
+
+struct ril_gprs_context_data_call {
+	guint status;
+	gint cid;
+	guint active;
+	int retry_time;
+	int prot;
+	gint mtu;
+	gchar *ifname;
+	gchar **dnses;
+	gchar **gateways;
+	gchar **addresses;
+};
+
+struct ril_gprs_context_data_call_list {
+	guint version;
+	guint num;
+	GSList *calls;
+};
+
+struct ril_gprs_context_cbd {
+	struct ril_gprs_context *gcd;
+	ofono_gprs_context_cb_t cb;
+	gpointer data;
+};
+
+struct ril_gprs_context_deactivate_req {
+	struct ril_gprs_context_cbd cbd;
+	gint cid;
+};
+
+#define ril_gprs_context_cbd_free g_free
+#define ril_gprs_context_deactivate_req_free g_free
+
+static inline struct ril_gprs_context *ril_gprs_context_get_data(
+					struct ofono_gprs_context *gprs)
+{
+	return ofono_gprs_context_get_data(gprs);
+}
+
+static struct ril_gprs_context_cbd *ril_gprs_context_cbd_new(
+	struct ril_gprs_context *gcd, ofono_gprs_context_cb_t cb, void *data)
+{
+	struct ril_gprs_context_cbd *cbd =
+		g_new0(struct ril_gprs_context_cbd, 1);
+
+	cbd->gcd = gcd;
+	cbd->cb = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+static struct ril_gprs_context_deactivate_req *
+	ril_gprs_context_deactivate_req_new(struct ril_gprs_context *gcd,
+	ofono_gprs_context_cb_t cb, void *data)
+{
+	struct ril_gprs_context_deactivate_req *req =
+		g_new0(struct ril_gprs_context_deactivate_req, 1);
+
+	req->cbd.gcd = gcd;
+	req->cbd.cb = cb;
+	req->cbd.data = data;
+	req->cid = gcd->active_call->cid;
+	return req;
+}
+
+
+static char *ril_gprs_context_netmask(const char *address)
+{
+	if (address) {
+		const char *suffix = strchr(address, '/');
+		if (suffix) {
+			int nbits = atoi(suffix + 1);
+			if (nbits > 0 && nbits < 33) {
+				const char* str;
+				struct in_addr in;
+				in.s_addr = htonl((nbits == 32) ? 0xffffffff :
+					((1 << nbits)-1) << (32-nbits));
+				str = inet_ntoa(in);
+				if (str) {
+					return g_strdup(str);
+				}
+			}
+		}
+	}
+	return g_strdup("255.255.255.0");
+}
+
+static const char *ril_gprs_ofono_protocol_to_ril(guint protocol)
+{
+	switch (protocol) {
+	case OFONO_GPRS_PROTO_IPV6:
+		return PROTO_IPV6_STR;
+	case OFONO_GPRS_PROTO_IPV4V6:
+		return PROTO_IPV4V6_STR;
+	case OFONO_GPRS_PROTO_IP:
+		return PROTO_IP_STR;
+	default:
+		return NULL;
+	}
+}
+
+static int ril_gprs_protocol_to_ofono(gchar *protocol_str)
+{
+	if (protocol_str) {
+		if (!strcmp(protocol_str, PROTO_IPV6_STR)) {
+			return OFONO_GPRS_PROTO_IPV6;
+		} else if (!strcmp(protocol_str, PROTO_IPV4V6_STR)) {
+			return OFONO_GPRS_PROTO_IPV4V6;
+		} else if (!strcmp(protocol_str, PROTO_IP_STR)) {
+			return OFONO_GPRS_PROTO_IP;
+		}
+	}
+	return -1;
+}
+
+static void ril_gprs_context_set_ipv4(struct ofono_gprs_context *gc,
+						char * const *ip_addr)
+{
+	const guint n = gutil_strv_length(ip_addr);
+
+	if (n > 0) {
+		ofono_gprs_context_set_ipv4_address(gc, ip_addr[0], TRUE);
+		if (n > 1) {
+			ofono_gprs_context_set_ipv4_netmask(gc, ip_addr[1]);
+		}
+	}
+}
+
+static void ril_gprs_context_set_ipv6(struct ofono_gprs_context *gc,
+						char * const *ipv6_addr)
+{
+	const guint n = gutil_strv_length(ipv6_addr);
+
+	if (n > 0) {
+		ofono_gprs_context_set_ipv6_address(gc, ipv6_addr[0]);
+		if (n > 1) {
+			const int p = atoi(ipv6_addr[1]);
+			if (p > 0 && p <= 128) {
+				ofono_gprs_context_set_ipv6_prefix_length(gc, p);
+			}
+		}
+	}
+}
+
+static void ril_gprs_context_data_call_free(
+				struct ril_gprs_context_data_call *call)
+{
+	if (call) {
+		g_free(call->ifname);
+		g_strfreev(call->dnses);
+		g_strfreev(call->addresses);
+		g_strfreev(call->gateways);
+		g_free(call);
+	}
+}
+
+static void ril_gprs_context_set_disconnected(struct ril_gprs_context *gcd)
+{
+	gcd->state = STATE_IDLE;
+	if (gcd->active_call) {
+		if (gcd->deactivate_req &&
+			gcd->deactivate_req->cid == gcd->active_call->cid) {
+			/* Mark this request as done */
+			gcd->deactivate_req->cbd.gcd = NULL;
+			gcd->deactivate_req = NULL;
+		}
+		ril_gprs_context_data_call_free(gcd->active_call);
+		gcd->active_call = NULL;
+	}
+	if (gcd->active_ctx_cid != CTX_ID_NONE) {
+		guint id = gcd->active_ctx_cid;
+		gcd->active_ctx_cid = CTX_ID_NONE;
+		ofono_gprs_context_deactivated(gcd->gc, id);
+	}
+}
+
+static void ril_gprs_split_ip_by_protocol(char **ip_array,
+						char ***split_ip_addr,
+						char ***split_ipv6_addr)
+{
+	const int n = gutil_strv_length(ip_array);
+	int i;
+
+	*split_ipv6_addr = *split_ip_addr = NULL;
+	for (i = 0; i < n && (!*split_ipv6_addr || !*split_ip_addr); i++) {
+		const char *addr = ip_array[i];
+		switch (ril_address_family(addr)) {
+		case AF_INET:
+			if (!*split_ip_addr) {
+				char *mask = ril_gprs_context_netmask(addr);
+				*split_ip_addr = g_strsplit(addr, "/", 2);
+				if (gutil_strv_length(*split_ip_addr) == 2) {
+					g_free((*split_ip_addr)[1]);
+					(*split_ip_addr)[1] = mask;
+				} else {
+					/* This is rather unlikely to happen */
+					*split_ip_addr =
+						gutil_strv_add(*split_ip_addr,
+									mask);
+					g_free(mask);
+				}
+			}
+			break;
+		case AF_INET6:
+			if (!*split_ipv6_addr) {
+				*split_ipv6_addr = g_strsplit(addr, "/", 2);
+			}
+		}
+	}
+}
+
+static void ril_gprs_split_gw_by_protocol(char **gw_array, char **ip_gw,
+								char **ipv6_gw)
+{
+	const int n = gutil_strv_length(gw_array);
+	int i;
+
+	*ip_gw = *ipv6_gw = NULL;
+	for (i = 0; i < n && (!*ipv6_gw || !*ip_gw); i++) {
+		const char *gw_addr = gw_array[i];
+		switch (ril_address_family(gw_addr)) {
+		case AF_INET:
+			if (!*ip_gw) *ip_gw = g_strdup(gw_addr);
+			break;
+		case AF_INET6:
+			if (!*ipv6_gw) *ipv6_gw = g_strdup(gw_addr);
+			break;
+		}
+	}
+}
+
+static void ril_gprs_split_dns_by_protocol(char **dns_array, char ***dns_addr,
+							char ***dns_ipv6_addr)
+{
+	const int n = gutil_strv_length(dns_array);
+	int i;
+
+	*dns_ipv6_addr = *dns_addr = 0;
+	for (i = 0; i < n; i++) {
+		const char *addr = dns_array[i];
+		switch (ril_address_family(addr)) {
+		case AF_INET:
+			*dns_addr = gutil_strv_add(*dns_addr, addr);
+			break;
+		case AF_INET6:
+			*dns_ipv6_addr = gutil_strv_add(*dns_ipv6_addr, addr);
+			break;
+		}
+	}
+}
+
+static gint ril_gprs_context_parse_data_call_compare(gconstpointer a,
+							gconstpointer b)
+{
+	const struct ril_gprs_context_data_call *ca = a;
+	const struct ril_gprs_context_data_call *cb = b;
+
+	if (ca->cid < cb->cid) {
+		return -1;
+	} else if (ca->cid > cb->cid) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+static void ril_gprs_context_data_call_free1(gpointer data)
+{
+	ril_gprs_context_data_call_free(data);
+}
+
+static void ril_gprs_context_data_call_list_free(
+			struct ril_gprs_context_data_call_list *list)
+{
+	if (list) {
+		g_slist_free_full(list->calls, ril_gprs_context_data_call_free1);
+		g_free(list);
+	}
+}
+
+static struct ril_gprs_context_data_call *ril_gprs_context_data_call_find(
+		struct ril_gprs_context_data_call_list *list, gint cid)
+{
+	if (list) {
+		GSList *entry;
+
+		for (entry = list->calls; entry; entry = entry->next) {
+			struct ril_gprs_context_data_call *call = entry->data;
+
+			if (call->cid == cid) {
+				return call;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+/* Only compares the stuff that's important to us */
+static gboolean ril_gprs_context_data_call_equal(
+			const struct ril_gprs_context_data_call *c1,
+			const struct ril_gprs_context_data_call *c2)
+{
+	if (!c1 && !c2) {
+		return TRUE;
+	} else if (c1 && c2) {
+		return c1->cid == c2->cid &&
+			c1->active == c2->active && c1->prot == c2->prot &&
+			!g_strcmp0(c1->ifname, c2->ifname) &&
+			gutil_strv_equal(c1->dnses, c2->dnses) &&
+			gutil_strv_equal(c1->gateways, c2->gateways) &&
+			gutil_strv_equal(c1->addresses, c2->addresses);
+	} else {
+		return FALSE;
+	}
+}
+
+static struct ril_gprs_context_data_call *
+	ril_gprs_context_parse_data_call(int version, GRilIoParser *rilp)
+{
+	char *prot;
+	struct ril_gprs_context_data_call *call =
+		g_new0(struct ril_gprs_context_data_call, 1);
+
+	grilio_parser_get_uint32(rilp, &call->status);
+	grilio_parser_get_int32(rilp, &call->retry_time);
+	grilio_parser_get_int32(rilp, &call->cid);
+	grilio_parser_get_uint32(rilp, &call->active);
+	prot = grilio_parser_get_utf8(rilp);
+	call->ifname = grilio_parser_get_utf8(rilp);
+	call->addresses = grilio_parser_split_utf8(rilp, " ");
+	call->dnses = grilio_parser_split_utf8(rilp, " ");
+	call->gateways = grilio_parser_split_utf8(rilp, " ");
+
+	call->prot = ril_gprs_protocol_to_ofono(prot);
+	if (call->prot < 0) {
+		ofono_error("Invalid type(protocol) specified: %s", prot);
+	}
+
+	g_free(prot);
+
+	if (version >= 9) {
+		/* PCSCF */
+		grilio_parser_skip_string(rilp);
+		if (version >= 11) {
+			/* MTU */
+			grilio_parser_get_int32(rilp, &call->mtu);
+		}
+	}
+
+	return call;
+}
+
+static struct ril_gprs_context_data_call_list *
+	ril_gprs_context_parse_data_call_list(const void *data, guint len)
+{
+	struct ril_gprs_context_data_call_list *reply =
+		g_new0(struct ril_gprs_context_data_call_list, 1);
+	GRilIoParser rilp;
+	unsigned int i, n;
+
+	grilio_parser_init(&rilp, data, len);
+	grilio_parser_get_uint32(&rilp, &reply->version);
+	grilio_parser_get_uint32(&rilp, &n);
+	DBG("version=%d,num=%d", reply->version, n);
+
+	for (i = 0; i < n && !grilio_parser_at_end(&rilp); i++) {
+		struct ril_gprs_context_data_call *call =
+			ril_gprs_context_parse_data_call(reply->version, &rilp);
+
+		DBG("%d [status=%d,retry=%d,cid=%d,"
+			"active=%d,type=%s,ifname=%s,mtu=%d,"
+			"address=%s, dns=%s %s,gateways=%s]",
+				i, call->status, call->retry_time,
+				call->cid, call->active,
+				ril_gprs_ofono_protocol_to_ril(call->prot),
+				call->ifname, call->mtu, call->addresses[0],
+				call->dnses[0],
+				(call->dnses[0] && call->dnses[1]) ?
+				call->dnses[1] : "",
+				call->gateways[0]);
+
+		reply->num++;
+		reply->calls = g_slist_insert_sorted(reply->calls, call,
+				ril_gprs_context_parse_data_call_compare);
+	}
+
+	return reply;
+}
+
+static void ril_gprs_context_call_list_changed(GRilIoChannel *io, guint event,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_gprs_context *gcd = user_data;
+	struct ofono_gprs_context *gc = gcd->gc;
+	struct ril_gprs_context_data_call *call = NULL;
+	struct ril_gprs_context_data_call *prev_call;
+	struct ril_gprs_context_data_call_list *unsol =
+		ril_gprs_context_parse_data_call_list(data, len);
+
+	if (gcd->active_call) {
+		/* Find our call */
+		call = ril_gprs_context_data_call_find(unsol,
+							gcd->active_call->cid);
+		if (call) {
+			/* Check if the call have been disconnected */
+			if (call->active == DATA_CALL_INACTIVE) {
+				ofono_error("Clearing active context");
+				ril_gprs_context_set_disconnected(gcd);
+				call = NULL;
+
+				/* Compare it agains the last known state */
+			} else if (ril_gprs_context_data_call_equal(call,
+							gcd->active_call)) {
+				DBG("call %u didn't change", call->cid);
+				call = NULL;
+			} else {
+				/* Steal it from the list */
+				DBG("call %u changed", call->cid);
+				unsol->calls = g_slist_remove(unsol->calls,
+									call);
+			}
+		} else {
+			ofono_error("Clearing active context");
+			ril_gprs_context_set_disconnected(gcd);
+		}
+	}
+
+	/* We don't need the rest of the list anymore */
+	ril_gprs_context_data_call_list_free(unsol);
+
+	if (!call) {
+		/* We are not interested */
+		return;
+	}
+
+	/* Store the updated call data */
+	prev_call = gcd->active_call;
+	gcd->active_call = call;
+
+	if (call->status != 0) {
+		ofono_info("data call status: %d", call->status);
+	}
+
+	if (call->active == DATA_CALL_ACTIVE) {
+		gboolean signal = FALSE;
+
+		if (call->ifname && g_strcmp0(call->ifname, prev_call->ifname)) {
+			DBG("interface changed");
+			signal = TRUE;
+			ofono_gprs_context_set_interface(gc, call->ifname);
+		}
+
+		if (!gutil_strv_equal(call->addresses, prev_call->addresses)) {
+			char **split_ip_addr = NULL;
+			char **split_ipv6_addr = NULL;
+
+			DBG("address changed");
+			signal = TRUE;
+
+			/* Pick 1 address of each protocol */
+			ril_gprs_split_ip_by_protocol(call->addresses,
+					&split_ip_addr, &split_ipv6_addr);
+
+			if ((call->prot == OFONO_GPRS_PROTO_IPV4V6 ||
+					call->prot == OFONO_GPRS_PROTO_IPV6) &&
+						split_ipv6_addr) {
+				ril_gprs_context_set_ipv6(gc, split_ipv6_addr);
+			}
+
+			if ((call->prot == OFONO_GPRS_PROTO_IPV4V6 ||
+					call->prot == OFONO_GPRS_PROTO_IP) &&
+						split_ip_addr) {
+				ril_gprs_context_set_ipv4(gc, split_ip_addr);
+			}
+
+			g_strfreev(split_ip_addr);
+			g_strfreev(split_ipv6_addr);
+		}
+
+		if (!gutil_strv_equal(call->gateways, prev_call->gateways)){
+			char *ip_gw = NULL;
+			char *ipv6_gw = NULL;
+
+			DBG("gateway changed");
+			signal = TRUE;
+
+			/* Pick 1 gw for each protocol*/
+			ril_gprs_split_gw_by_protocol(call->gateways,
+							&ip_gw, &ipv6_gw);
+
+			if ((call->prot == OFONO_GPRS_PROTO_IPV4V6 ||
+					call->prot == OFONO_GPRS_PROTO_IPV6) &&
+						ipv6_gw) {
+				ofono_gprs_context_set_ipv6_gateway(gc, ipv6_gw);
+			}
+
+			if ((call->prot == OFONO_GPRS_PROTO_IPV4V6 ||
+					call->prot == OFONO_GPRS_PROTO_IP) &&
+						ip_gw) {
+				ofono_gprs_context_set_ipv4_gateway(gc, ip_gw);
+			}
+
+			g_free(ip_gw);
+			g_free(ipv6_gw);
+		}
+
+		if (!gutil_strv_equal(call->dnses, prev_call->dnses)){
+			char **dns_ip = NULL;
+			char **dns_ipv6 = NULL;
+
+			DBG("name server(s) changed");
+			signal = TRUE;
+
+			/* split based on protocol*/
+			ril_gprs_split_dns_by_protocol(call->dnses,
+							&dns_ip, &dns_ipv6);
+
+			if ((call->prot == OFONO_GPRS_PROTO_IPV4V6 ||
+					call->prot == OFONO_GPRS_PROTO_IPV6) &&
+						dns_ipv6) {
+				ofono_gprs_context_set_ipv6_dns_servers(gc,
+						(const char **) dns_ipv6);
+			}
+
+			if ((call->prot == OFONO_GPRS_PROTO_IPV4V6 ||
+				call->prot == OFONO_GPRS_PROTO_IP) && dns_ip) {
+				ofono_gprs_context_set_ipv4_dns_servers(gc,
+							(const char**)dns_ip);
+			}
+
+			g_strfreev(dns_ip);
+			g_strfreev(dns_ipv6);
+		}
+
+		if (signal) {
+			ofono_gprs_context_signal_change(gc, call->cid);
+		}
+	}
+
+	ril_gprs_context_data_call_free(prev_call);
+}
+
+static void ril_gprs_context_activate_primary_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_gprs_context_cbd *cbd = user_data;
+	ofono_gprs_context_cb_t cb = cbd->cb;
+	struct ril_gprs_context *gcd = cbd->gcd;
+	struct ofono_gprs_context *gc = gcd->gc;
+	struct ofono_error error;
+	struct ril_gprs_context_data_call_list *reply = NULL;
+	struct ril_gprs_context_data_call *call;
+	char **split_ip_addr = NULL;
+	char **split_ipv6_addr = NULL;
+	char* ip_gw = NULL;
+	char* ipv6_gw = NULL;
+	char** dns_addr = NULL;
+	char** dns_ipv6_addr = NULL;
+
+	ofono_info("setting up data call");
+
+	ril_error_init_ok(&error);
+	if (status != RIL_E_SUCCESS) {
+		ofono_error("GPRS context: Reply failure: %s",
+						ril_error_to_string(status));
+		error.type = OFONO_ERROR_TYPE_FAILURE;
+		error.error = status;
+		ril_gprs_context_set_disconnected(gcd);
+		goto done;
+	}
+
+	reply = ril_gprs_context_parse_data_call_list(data, len);
+	if (reply->num != 1) {
+		ofono_error("Number of data calls: %u", reply->num);
+		ril_error_init_failure(&error);
+		ril_gprs_context_set_disconnected(gcd);
+		goto done;
+	}
+
+	call = reply->calls->data;
+
+	if (call->status != 0) {
+		ofono_error("Unexpected data call status %d", call->status);
+		error.type = OFONO_ERROR_TYPE_FAILURE;
+		error.error = call->status;
+		goto done;
+	}
+
+	/* Must have interface */
+	if (!call->ifname) {
+		ofono_error("GPRS context: No interface");
+		error.type = OFONO_ERROR_TYPE_FAILURE;
+		error.error = EINVAL;
+		ril_gprs_context_set_disconnected(gcd);
+		goto done;
+	}
+
+	/* Check the ip address */
+	ril_gprs_split_ip_by_protocol(call->addresses, &split_ip_addr,
+						&split_ipv6_addr);
+	if (!split_ip_addr && !split_ipv6_addr) {
+		ofono_error("GPRS context: No IP address");
+		error.type = OFONO_ERROR_TYPE_FAILURE;
+		error.error = EINVAL;
+		ril_gprs_context_set_disconnected(gcd);
+		goto done;
+	}
+
+	/* Steal the call data from the list */
+	g_slist_free(reply->calls);
+	reply->calls = NULL;
+	ril_gprs_context_data_call_free(gcd->active_call);
+	gcd->active_call = call;
+	gcd->state = STATE_ACTIVE;
+
+	ofono_gprs_context_set_interface(gc, call->ifname);
+	ril_gprs_split_gw_by_protocol(call->gateways, &ip_gw, &ipv6_gw);
+	ril_gprs_split_dns_by_protocol(call->dnses, &dns_addr, &dns_ipv6_addr);
+
+	/* TODO:
+	 * RILD can return multiple addresses; oFono only supports setting
+	 * a single IPv4 and single IPV6 address. At this time, we only use
+	 * the first address. It's possible that a RIL may just specify
+	 * the end-points of the point-to-point connection, in which case this
+	 * code will need to changed to handle such a device.
+	 */
+
+	if (split_ipv6_addr &&
+			(call->prot == OFONO_GPRS_PROTO_IPV6 ||
+			call->prot == OFONO_GPRS_PROTO_IPV4V6)) {
+
+		ril_gprs_context_set_ipv6(gc, split_ipv6_addr);
+		ofono_gprs_context_set_ipv6_gateway(gc, ipv6_gw);
+		ofono_gprs_context_set_ipv6_dns_servers(gc,
+						(const char **) dns_ipv6_addr);
+	}
+
+	if (split_ip_addr &&
+			(call->prot == OFONO_GPRS_PROTO_IP ||
+			call->prot == OFONO_GPRS_PROTO_IPV4V6)) {
+		ril_gprs_context_set_ipv4(gc, split_ip_addr);
+		ofono_gprs_context_set_ipv4_gateway(gc, ip_gw);
+		ofono_gprs_context_set_ipv4_dns_servers(gc,
+						(const char **) dns_addr);
+	}
+
+done:
+	ril_gprs_context_data_call_list_free(reply);
+	g_strfreev(split_ip_addr);
+	g_strfreev(split_ipv6_addr);
+	g_strfreev(dns_addr);
+	g_strfreev(dns_ipv6_addr);
+	g_free(ip_gw);
+	g_free(ipv6_gw);
+
+	cb(&error, cbd->data);
+}
+
+static void ril_gprs_context_activate_primary(struct ofono_gprs_context *gc,
+				const struct ofono_gprs_primary_context *ctx,
+				ofono_gprs_context_cb_t cb, void *data)
+{
+	struct ril_gprs_context *gcd = ril_gprs_context_get_data(gc);
+	struct ofono_netreg *netreg = ril_modem_ofono_netreg(gcd->modem);
+	struct ofono_gprs *gprs = ril_modem_ofono_gprs(gcd->modem);
+	const int rs = ofono_netreg_get_status(netreg);
+	const gchar *protocol_str;
+	GRilIoRequest* req;
+	int tech, auth;
+
+	/* Let's make sure that we aren't connecting when roaming not allowed */
+	if (rs == NETWORK_REGISTRATION_STATUS_ROAMING) {
+		if (!ofono_gprs_get_roaming_allowed(gprs) &&
+			ril_netreg_check_if_really_roaming(netreg, rs) ==
+					NETWORK_REGISTRATION_STATUS_ROAMING) {
+			struct ofono_error error;
+			ofono_info("Can't activate context %d (roaming)",
+								ctx->cid);
+			cb(ril_error_failure(&error), data);
+			return;
+		}
+	}
+
+	ofono_info("Activating context: %d", ctx->cid);
+	protocol_str = ril_gprs_ofono_protocol_to_ril(ctx->proto);
+	GASSERT(protocol_str);
+
+	/* ril.h has this to say about the radio tech parameter:
+	 *
+	 * ((const char **)data)[0] Radio technology to use: 0-CDMA,
+	 *                          1-GSM/UMTS, 2... for values above 2
+	 *                          this is RIL_RadioTechnology + 2.
+	 *
+	 * Makes little sense but it is what it is.
+	 */
+	tech = gcd->network->data.ril_tech;
+	if (tech > 2) {
+		tech += 2;
+	} else {
+		/*
+		 * This value used to be hardcoded, let's keep using it
+		 * as the default.
+		 */
+		tech = RADIO_TECH_HSPA;
+	}
+
+        /*
+         * We do the same as in $AOSP/frameworks/opt/telephony/src/java/com/
+         * android/internal/telephony/dataconnection/DataConnection.java,
+         * onConnect(), and use authentication or not depending on whether
+         * the user field is empty or not.
+         */
+	auth = (ctx->username && ctx->username[0]) ?
+					RIL_AUTH_BOTH : RIL_AUTH_NONE;
+
+	/*
+	 * TODO: add comments about tethering, other non-public
+	 * profiles...
+	 */
+	req = grilio_request_new();
+	grilio_request_append_int32(req, SETUP_DATA_CALL_PARAMS);
+	grilio_request_append_format(req, "%d", tech);
+	grilio_request_append_utf8(req, DATA_PROFILE_DEFAULT_STR);
+	grilio_request_append_utf8(req, ctx->apn);
+	grilio_request_append_utf8(req, ctx->username);
+	grilio_request_append_utf8(req, ctx->password);
+	grilio_request_append_format(req, "%d", auth);
+	grilio_request_append_utf8(req, protocol_str);
+
+	GASSERT(ctx->cid != CTX_ID_NONE);
+	gcd->active_ctx_cid = ctx->cid;
+	gcd->state = STATE_ACTIVATING;
+
+	grilio_queue_send_request_full(gcd->q, req, RIL_REQUEST_SETUP_DATA_CALL,
+		ril_gprs_context_activate_primary_cb, ril_gprs_context_cbd_free,
+		ril_gprs_context_cbd_new(gcd, cb, data));
+	grilio_request_unref(req);
+}
+
+static void ril_gprs_context_deactivate_data_call_cb(GRilIoChannel *io, int err,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_gprs_context_deactivate_req *req = user_data;
+	struct ril_gprs_context *gcd = req->cbd.gcd;
+
+	if (!gcd) {
+		/*
+		 * ril_gprs_context_remove() zeroes gcd pointer for the
+		 * pending ril_gprs_context_deactivate_req. Or we may have
+		 * received RIL_UNSOL_DATA_CALL_LIST_CHANGED event before
+		 * RIL_REQUEST_DEACTIVATE_DATA_CALL completes, in which
+		 * case gcd will also be NULL. In any case, it means that
+		 * there's nothing left for us to do here. Just ignore it.
+		 */
+		DBG("late completion, cid: %d err: %d", req->cid, err);
+	} else {
+		ofono_gprs_context_cb_t cb = req->cbd.cb;
+
+		/* Mark it as done */
+		if (gcd->deactivate_req == req) {
+			gcd->deactivate_req = NULL;
+		}
+
+		if (err == RIL_E_SUCCESS) {
+			GASSERT(gcd->active_call &&
+					gcd->active_call->cid == req->cid);
+			ril_gprs_context_set_disconnected(gcd);
+			ofono_info("Deactivated data call");
+			if (cb) {
+				cb(ril_error_ok(&error), req->cbd.data);
+			}
+		} else {
+			ofono_error("Deactivate failure: %s",
+						ril_error_to_string(err));
+			if (cb) {
+				cb(ril_error_failure(&error), req->cbd.data);
+			}
+		}
+	}
+}
+
+static void ril_gprs_context_deactivate_data_call(struct ril_gprs_context *gcd,
+					ofono_gprs_context_cb_t cb, void *data)
+{
+	GRilIoRequest *req = grilio_request_new();
+
+	/* Overlapping deactivate requests make no sense */
+	GASSERT(!gcd->deactivate_req);
+	if (gcd->deactivate_req) {
+		gcd->deactivate_req->cbd.gcd = NULL;
+	}
+	gcd->deactivate_req =
+		ril_gprs_context_deactivate_req_new(gcd, cb, data);
+
+	/* Caller is responsible for checking gcd->active_call */
+	GASSERT(gcd->active_call);
+	grilio_request_append_int32(req, DEACTIVATE_DATA_CALL_PARAMS);
+	grilio_request_append_format(req, "%d", gcd->active_call->cid);
+	grilio_request_append_format(req, "%d",
+					RIL_DEACTIVATE_DATA_CALL_NO_REASON);
+
+	/*
+	 * Send it to GRilIoChannel so that it doesn't get cancelled
+	 * by ril_gprs_context_remove()
+	 */
+	grilio_channel_send_request_full(gcd->io, req,
+		RIL_REQUEST_DEACTIVATE_DATA_CALL,
+		ril_gprs_context_deactivate_data_call_cb,
+		ril_gprs_context_deactivate_req_free,
+		gcd->deactivate_req);
+	grilio_request_unref(req);
+	gcd->state = STATE_DEACTIVATING;
+}
+
+static void ril_gprs_context_deactivate_primary(struct ofono_gprs_context *gc,
+		unsigned int id, ofono_gprs_context_cb_t cb, void *data)
+{
+	struct ril_gprs_context *gcd = ril_gprs_context_get_data(gc);
+
+	GASSERT(cb);
+	GASSERT(gcd->active_call && gcd->active_ctx_cid == id);
+	ofono_info("Deactivate primary");
+
+	if (gcd->active_call && gcd->active_ctx_cid == id) {
+		ril_gprs_context_deactivate_data_call(gcd, cb, data);
+	} else {
+		struct ofono_error error;
+		cb(ril_error_ok(&error), data);
+	}
+}
+
+static void ril_gprs_context_detach_shutdown(struct ofono_gprs_context *gc,
+						unsigned int id)
+{
+	struct ril_gprs_context *gcd = ril_gprs_context_get_data(gc);
+
+	DBG("%d", id);
+	GASSERT(gcd->active_ctx_cid == id);
+	if (gcd->active_call && !gcd->deactivate_req) {
+		ril_gprs_context_deactivate_data_call(gcd, NULL, NULL);
+	}
+}
+
+static int ril_gprs_context_probe(struct ofono_gprs_context *gc,
+					unsigned int vendor, void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_gprs_context *gcd = g_new0(struct ril_gprs_context, 1);
+
+	DBG("");
+	gcd->gc = gc;
+	gcd->modem = modem;
+	gcd->network = ril_network_ref(modem->network);
+	gcd->io = grilio_channel_ref(ril_modem_io(modem));
+	gcd->q = grilio_queue_new(gcd->io);
+	gcd->regid = grilio_channel_add_unsol_event_handler(gcd->io,
+			ril_gprs_context_call_list_changed,
+			RIL_UNSOL_DATA_CALL_LIST_CHANGED, gcd);
+	ril_gprs_context_set_disconnected(gcd);
+	ofono_gprs_context_set_data(gc, gcd);
+	return 0;
+}
+
+static void ril_gprs_context_remove(struct ofono_gprs_context *gc)
+{
+	struct ril_gprs_context *gcd = ril_gprs_context_get_data(gc);
+
+	DBG("");
+	ofono_gprs_context_set_data(gc, NULL);
+
+	if (gcd->active_call && !gcd->deactivate_req) {
+		ril_gprs_context_deactivate_data_call(gcd, NULL, NULL);
+	}
+
+	if (gcd->deactivate_req) {
+		gcd->deactivate_req->cbd.gcd = NULL;
+	}
+
+	ril_network_unref(gcd->network);
+	grilio_channel_remove_handler(gcd->io, gcd->regid);
+	grilio_channel_unref(gcd->io);
+	grilio_queue_cancel_all(gcd->q, FALSE);
+	grilio_queue_unref(gcd->q);
+	ril_gprs_context_data_call_free(gcd->active_call);
+	g_free(gcd);
+}
+
+const struct ofono_gprs_context_driver ril_gprs_context_driver = {
+	.name                   = RILMODEM_DRIVER,
+	.probe                  = ril_gprs_context_probe,
+	.remove                 = ril_gprs_context_remove,
+	.activate_primary       = ril_gprs_context_activate_primary,
+	.deactivate_primary     = ril_gprs_context_deactivate_primary,
+	.detach_shutdown        = ril_gprs_context_detach_shutdown,
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_log.h

@@ -0,0 +1,31 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#ifndef RIL_LOG_H
+#define RIL_LOG_H
+
+#define GLOG_MODULE_NAME ril_log
+#include <gutil_log.h>
+#include <ofono/log.h>
+
+#endif /* RIL_LOG_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_mce.c

@@ -0,0 +1,135 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_mce.h"
+#include "ril_constants.h"
+
+#include <grilio_channel.h>
+#include <grilio_request.h>
+
+#include <ofono/log.h>
+#include <ofono/dbus.h>
+
+#include <gdbus.h>
+
+#define MCE_SERVICE             "com.nokia.mce"
+#define MCE_SIGNAL_IF           "com.nokia.mce.signal"
+#define MCE_DISPLAY_SIG         "display_status_ind"
+#define MCE_DISPLAY_OFF_STRING  "off"
+
+struct ril_mce {
+	GRilIoChannel *io;
+	DBusConnection *conn;
+	int screen_state;
+	guint daemon_watch;
+	guint signal_watch;
+};
+
+static void ril_mce_send_screen_state(struct ril_mce *mce, gboolean on)
+{
+	GRilIoRequest *req = grilio_request_sized_new(8);
+
+	grilio_request_append_int32(req, 1);    /* Number of params */
+	grilio_request_append_int32(req, on);   /* screen on/off */
+
+	grilio_channel_send_request(mce->io, req, RIL_REQUEST_SCREEN_STATE);
+	grilio_request_unref(req);
+}
+
+static gboolean ril_mce_display_changed(DBusConnection *conn,
+				DBusMessage *message, void *user_data)
+{
+	DBusMessageIter iter;
+
+	if (dbus_message_iter_init(message, &iter) &&
+		dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING) {
+		struct ril_mce *mce = user_data;
+		const char *value = NULL;
+		int state;
+
+		dbus_message_iter_get_basic(&iter, &value);
+		DBG(" %s", value);
+
+		/* It is on if it's not off */
+		state = (g_strcmp0(value, MCE_DISPLAY_OFF_STRING) != 0);
+		if (mce->screen_state != state) {
+			mce->screen_state = state;
+			ril_mce_send_screen_state(mce, state);
+		}
+	} else {
+		DBG("");
+	}
+
+	return TRUE;
+}
+
+static void ril_mce_connect(DBusConnection *conn, void *user_data)
+{
+	struct ril_mce *mce = user_data;
+
+	DBG("");
+	if (!mce->signal_watch) {
+		mce->signal_watch = g_dbus_add_signal_watch(conn,
+			MCE_SERVICE, NULL, MCE_SIGNAL_IF, MCE_DISPLAY_SIG,
+			ril_mce_display_changed, mce, NULL);
+	}
+}
+
+static void ril_mce_disconnect(DBusConnection *conn, void *user_data)
+{
+	struct ril_mce *mce = user_data;
+
+	DBG("");
+	if (mce->signal_watch) {
+		g_dbus_remove_watch(conn, mce->signal_watch);
+		mce->signal_watch = 0;
+	}
+}
+
+struct ril_mce *ril_mce_new(GRilIoChannel *io)
+{
+	struct ril_mce *mce = g_new0(struct ril_mce, 1);
+
+	mce->conn = dbus_connection_ref(ofono_dbus_get_connection());
+	mce->io = grilio_channel_ref(io);
+	mce->screen_state = -1;
+	mce->daemon_watch = g_dbus_add_service_watch(mce->conn, MCE_SERVICE,
+		ril_mce_connect, ril_mce_disconnect, mce, NULL);
+
+	return mce;
+}
+
+void ril_mce_free(struct ril_mce *mce)
+{
+	if (mce) {
+		if (mce->signal_watch) {
+			g_dbus_remove_watch(mce->conn, mce->signal_watch);
+		}
+		if (mce->daemon_watch) {
+			g_dbus_remove_watch(mce->conn, mce->daemon_watch);
+		}
+		dbus_connection_unref(mce->conn);
+		grilio_channel_unref(mce->io);
+		g_free(mce);
+	}
+}
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_mce.h

@@ -0,0 +1,32 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#ifndef RIL_MCE_H
+#define RIL_MCE_H
+
+#include "ril_types.h"
+
+struct ril_mce *ril_mce_new(GRilIoChannel *io);
+void ril_mce_free(struct ril_mce *mce);
+
+#endif /* RIL_MCE_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_modem.c

@@ -0,0 +1,499 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_network.h"
+#include "ril_radio.h"
+#include "ril_sim_card.h"
+#include "ril_data.h"
+#include "ril_util.h"
+#include "ril_log.h"
+
+#include "ofono.h"
+
+#define MAX_PDP_CONTEXTS        (2)
+#define ONLINE_TIMEOUT_SECS     (15) /* 20 sec is hardcoded in ofono core */
+
+enum ril_modem_power_state {
+	POWERED_OFF,
+	POWERED_ON,
+	POWERING_OFF
+};
+
+enum ril_modem_online_state {
+	OFFLINE,
+	GOING_ONLINE,
+	ONLINE,
+	GOING_OFFLINE
+};
+
+struct ril_modem_online_request {
+	ofono_modem_online_cb_t cb;
+	struct ril_modem_data *md;
+	void *data;
+	guint timeout_id;
+};
+
+struct ril_modem_data {
+	struct ril_modem modem;
+	GRilIoQueue *q;
+	struct ofono_radio_settings *radio_settings;
+	char *default_name;
+	char *imei;
+	gboolean pre_sim_done;
+	gboolean devinfo_created;
+	gboolean allow_data;
+
+	guint online_check_id;
+	enum ril_modem_power_state power_state;
+	gulong radio_state_event_id;
+
+	ril_modem_cb_t removed_cb;
+	void *removed_cb_data;
+
+	struct ril_modem_online_request set_online;
+	struct ril_modem_online_request set_offline;
+};
+
+#define RADIO_POWER_TAG(md) (md)
+
+static struct ril_modem_data *ril_modem_data_from_ofono(struct ofono_modem *o)
+{
+	struct ril_modem_data *md = ofono_modem_get_data(o);
+	GASSERT(md->modem.ofono == o);
+	return md;
+}
+
+static struct ril_modem_data *ril_modem_data_from_modem(struct ril_modem *m)
+{
+	return m ? G_CAST(m, struct ril_modem_data, modem) : NULL;
+}
+
+static void *ril_modem_get_atom_data(struct ril_modem *modem,
+						enum ofono_atom_type type)
+{
+	if (modem && modem->ofono) {
+		struct ofono_atom *atom =
+			__ofono_modem_find_atom(modem->ofono, type);
+
+		if (atom) {
+			return __ofono_atom_get_data(atom);
+		}
+	}
+
+	return NULL;
+}
+
+struct ofono_sim *ril_modem_ofono_sim(struct ril_modem *modem)
+{
+	return ril_modem_get_atom_data(modem, OFONO_ATOM_TYPE_SIM);
+}
+
+struct ofono_gprs *ril_modem_ofono_gprs(struct ril_modem *modem)
+{
+	return ril_modem_get_atom_data(modem, OFONO_ATOM_TYPE_GPRS);
+}
+
+struct ofono_netreg *ril_modem_ofono_netreg(struct ril_modem *modem)
+{
+	return ril_modem_get_atom_data(modem, OFONO_ATOM_TYPE_NETREG);
+}
+
+void ril_modem_delete(struct ril_modem *md)
+{
+	if (md && md->ofono) {
+		ofono_modem_remove(md->ofono);
+	}
+}
+
+void ril_modem_set_removed_cb(struct ril_modem *modem, ril_modem_cb_t cb,
+								void *data)
+{
+	struct ril_modem_data *md = ril_modem_data_from_modem(modem);
+
+	md->removed_cb = cb;
+	md->removed_cb_data = data;
+}
+
+static void ril_modem_check_devinfo(struct ril_modem_data *md)
+{
+	/* devinfo driver assumes that IMEI is known */
+	if (md->imei && md->pre_sim_done && !md->devinfo_created &&
+							md->modem.ofono) {
+		md->devinfo_created = TRUE;
+		ofono_devinfo_create(md->modem.ofono, 0, RILMODEM_DRIVER, md);
+	}
+}
+
+void ril_modem_set_imei(struct ril_modem *modem, const char *imei)
+{
+	struct ril_modem_data *md = ril_modem_data_from_modem(modem);
+
+	if (md) {
+		g_free(md->imei);
+		modem->imei = md->imei = g_strdup(imei);
+		ril_modem_check_devinfo(md);
+	}
+}
+
+static void ril_modem_online_request_ok(struct ril_modem_online_request *req)
+{
+	if (req->timeout_id) {
+		g_source_remove(req->timeout_id);
+		req->timeout_id = 0;
+	}
+
+	if (req->cb) {
+		struct ofono_error error;
+		ofono_modem_online_cb_t cb = req->cb;
+		void *data = req->data;
+
+		req->cb = NULL;
+		req->data = NULL;
+		cb(ril_error_ok(&error), data);
+	}
+}
+
+static void ril_modem_update_online_state(struct ril_modem_data *md)
+{
+	switch (md->modem.radio->state) {
+	case RADIO_STATE_ON:
+		DBG("online");
+		ril_modem_online_request_ok(&md->set_online);
+		break;
+
+	case RADIO_STATE_OFF:
+	case RADIO_STATE_UNAVAILABLE:
+		DBG("offline");
+		ril_modem_online_request_ok(&md->set_offline);
+		break;
+
+	default:
+		break;
+	}
+
+	if (!md->set_offline.timeout_id && !md->set_online.timeout_id &&
+					md->power_state == POWERING_OFF) {
+		md->power_state = POWERED_OFF;
+		if (md->modem.ofono) {
+			ofono_modem_set_powered(md->modem.ofono, FALSE);
+		}
+	}
+}
+
+static gboolean ril_modem_online_request_timeout(gpointer data)
+{
+	struct ril_modem_online_request *req = data;
+	struct ofono_error error;
+	ofono_modem_online_cb_t cb = req->cb;
+	void *cb_data = req->data;
+
+	GASSERT(req->timeout_id);
+	GASSERT(cb);
+
+	req->timeout_id = 0;
+	req->cb = NULL;
+	req->data = NULL;
+	cb(ril_error_failure(&error), cb_data);
+	ril_modem_update_online_state(req->md);
+	return FALSE;
+}
+
+static gboolean ril_modem_online_check(gpointer data)
+{
+	struct ril_modem_data *md = data;
+
+	GASSERT(md->online_check_id);
+	md->online_check_id = 0;
+	ril_modem_update_online_state(md);
+	return FALSE;
+}
+
+static void ril_modem_schedule_online_check(struct ril_modem_data *md)
+{
+	if (!md->online_check_id) {
+		md->online_check_id = g_idle_add(ril_modem_online_check, md);
+	}
+}
+
+static void ril_modem_update_radio_settings(struct ril_modem_data *md)
+{
+	if (md->modem.radio->state == RADIO_STATE_ON) {
+		if (!md->radio_settings) {
+			DBG("Initializing radio settings interface");
+			md->radio_settings =
+				ofono_radio_settings_create(md->modem.ofono, 0,
+							RILMODEM_DRIVER, md);
+		}
+	} else if (md->radio_settings) {
+		DBG("Removing radio settings interface");
+		ofono_radio_settings_remove(md->radio_settings);
+		md->radio_settings = NULL;
+	}
+}
+
+static void ril_modem_radio_state_cb(struct ril_radio *radio, void *data)
+{
+	struct ril_modem_data *md = data;
+
+	GASSERT(md->modem.radio == radio);
+	ril_modem_update_radio_settings(md);
+	ril_modem_update_online_state(md);
+};
+
+static void ril_modem_pre_sim(struct ofono_modem *modem)
+{
+	struct ril_modem_data *md = ril_modem_data_from_ofono(modem);
+
+	DBG("%s", ofono_modem_get_path(modem));
+	md->pre_sim_done = TRUE;
+	ril_modem_check_devinfo(md);
+	ofono_sim_create(modem, 0, RILMODEM_DRIVER, md);
+	ofono_voicecall_create(modem, 0, RILMODEM_DRIVER, md);
+	ril_modem_update_radio_settings(md);
+	if (!md->radio_state_event_id) {
+		md->radio_state_event_id =
+			ril_radio_add_state_changed_handler(md->modem.radio,
+					ril_modem_radio_state_cb, md);
+	}
+}
+
+static void ril_modem_post_sim(struct ofono_modem *modem)
+{
+	struct ril_modem_data *md = ril_modem_data_from_ofono(modem);
+	struct ofono_gprs *gprs;
+
+	DBG("%s", ofono_modem_get_path(modem));
+	ofono_sms_create(modem, 0, RILMODEM_DRIVER, md);
+	gprs = ofono_gprs_create(modem, 0, RILMODEM_DRIVER, md);
+	if (gprs) {
+		int i;
+
+		for (i = 0; i < MAX_PDP_CONTEXTS; i++) {
+			struct ofono_gprs_context *gc =
+				ofono_gprs_context_create(modem, 0,
+						RILMODEM_DRIVER, md);
+			if (gc == NULL)
+				break;
+
+			ofono_gprs_add_context(gprs, gc);
+		}
+	}
+
+	ofono_phonebook_create(modem, 0, RILMODEM_DRIVER, md);
+	ofono_call_forwarding_create(modem, 0, RILMODEM_DRIVER, md);
+	ofono_call_barring_create(modem, 0, RILMODEM_DRIVER, md);
+	ofono_stk_create(modem, 0, RILMODEM_DRIVER, md);
+	ofono_message_waiting_register(ofono_message_waiting_create(modem));
+}
+
+static void ril_modem_post_online(struct ofono_modem *modem)
+{
+	struct ril_modem_data *md = ril_modem_data_from_ofono(modem);
+
+	DBG("%s", ofono_modem_get_path(modem));
+	ofono_call_volume_create(modem, 0, RILMODEM_DRIVER, md);
+	ofono_netreg_create(modem, 0, RILMODEM_DRIVER, md);
+	ofono_ussd_create(modem, 0, RILMODEM_DRIVER, md);
+	ofono_call_settings_create(modem, 0, RILMODEM_DRIVER, md);
+	ofono_oem_raw_create(modem, 0, RILMODEM_DRIVER, md);
+}
+
+static void ril_modem_set_online(struct ofono_modem *modem, ofono_bool_t online,
+				ofono_modem_online_cb_t cb, void *data)
+{
+	struct ril_modem_data *md = ril_modem_data_from_ofono(modem);
+	struct ril_modem_online_request *req;
+
+	DBG("%s going %sline", ofono_modem_get_path(modem),
+						online ? "on" : "off");
+
+	if (online) {
+		ril_radio_power_on(md->modem.radio, RADIO_POWER_TAG(md));
+		req = &md->set_online;
+	} else {
+		ril_radio_power_off(md->modem.radio, RADIO_POWER_TAG(md));
+		req = &md->set_offline;
+	}
+
+	req->cb = cb;
+	req->data = data;
+	if (req->timeout_id) {
+		g_source_remove(req->timeout_id);
+	}
+	req->timeout_id = g_timeout_add_seconds(ONLINE_TIMEOUT_SECS,
+					ril_modem_online_request_timeout, req);
+	ril_modem_schedule_online_check(md);
+}
+
+static int ril_modem_enable(struct ofono_modem *modem)
+{
+	struct ril_modem_data *md = ril_modem_data_from_ofono(modem);
+
+	DBG("%s", ofono_modem_get_path(modem));
+	md->power_state = POWERED_ON;
+	return 0;
+}
+
+static int ril_modem_disable(struct ofono_modem *modem)
+{
+	struct ril_modem_data *md = ril_modem_data_from_ofono(modem);
+
+	DBG("%s", ofono_modem_get_path(modem));
+	if (md->set_online.timeout_id || md->set_offline.timeout_id) {
+		md->power_state = POWERING_OFF;
+		return -EINPROGRESS;
+	} else {
+		md->power_state = POWERED_OFF;
+		return 0;
+	}
+}
+
+static int ril_modem_probe(struct ofono_modem *modem)
+{
+	DBG("%s", ofono_modem_get_path(modem));
+	return 0;
+}
+
+static void ril_modem_remove(struct ofono_modem *ofono)
+{
+	struct ril_modem_data *md = ril_modem_data_from_ofono(ofono);
+	struct ril_modem *modem = &md->modem;
+
+	DBG("%s", ril_modem_get_path(modem));
+	if (md->removed_cb) {
+		ril_modem_cb_t cb = md->removed_cb;
+		void *data = md->removed_cb_data;
+
+		md->removed_cb = NULL;
+		md->removed_cb_data = NULL;
+		cb(modem, data);
+	}
+
+	ofono_modem_set_data(ofono, NULL);
+
+	ril_radio_remove_handler(modem->radio, md->radio_state_event_id);
+	ril_radio_power_off(modem->radio, RADIO_POWER_TAG(md));
+	ril_radio_unref(modem->radio);
+
+	if (md->online_check_id) {
+		g_source_remove(md->online_check_id);
+	}
+
+	if (md->set_online.timeout_id) {
+		g_source_remove(md->set_online.timeout_id);
+	}
+
+	if (md->set_offline.timeout_id) {
+		g_source_remove(md->set_offline.timeout_id);
+	}
+
+	ril_network_unref(modem->network);
+	ril_sim_card_unref(modem->sim_card);
+	ril_data_unref(modem->data);
+	grilio_channel_unref(modem->io);
+	grilio_queue_cancel_all(md->q, FALSE);
+	grilio_queue_unref(md->q);
+	g_free(md->default_name);
+	g_free(md->imei);
+	g_free(md);
+}
+
+struct ril_modem *ril_modem_create(GRilIoChannel *io,
+		const struct ril_slot_info *slot, struct ril_radio *radio,
+		struct ril_network *network, struct ril_sim_card *card,
+		struct ril_data *data)
+{
+	/* Skip the slash from the path, it looks like "/ril_0" */
+	struct ofono_modem *ofono = ofono_modem_create(slot->path + 1,
+							RILMODEM_DRIVER);
+	if (ofono) {
+		int err;
+		struct ril_modem_data *md = g_new0(struct ril_modem_data, 1);
+		struct ril_modem *modem = &md->modem;
+
+		/* Copy config */
+		modem->config = *slot->config;
+		modem->imei = md->imei = g_strdup(slot->imei);
+		if (slot->config->default_name &&
+					slot->config->default_name[0]) {
+			md->default_name = g_strdup(slot->config->default_name);
+		} else {
+			md->default_name = g_strdup_printf("SIM%u",
+						slot->config->slot + 1);
+		}
+		modem->config.default_name = md->default_name;
+
+		modem->ofono = ofono;
+		modem->radio = ril_radio_ref(radio);
+		modem->network = ril_network_ref(network);
+		modem->sim_card = ril_sim_card_ref(card);
+		modem->data = ril_data_ref(data);
+		modem->io = grilio_channel_ref(io);
+		md->q = grilio_queue_new(io);
+		md->set_online.md = md;
+		md->set_offline.md = md;
+		ofono_modem_set_data(ofono, md);
+		err = ofono_modem_register(ofono);
+		if (!err) {
+			ril_radio_power_cycle(modem->radio);
+			ril_radio_power_on(modem->radio, RADIO_POWER_TAG(md));
+			GASSERT(io->connected);
+
+			/*
+			 * ofono_modem_reset sets Powered to TRUE without
+			 * issuing PropertyChange signal.
+			 */
+			ofono_modem_set_powered(modem->ofono, FALSE);
+			ofono_modem_set_powered(modem->ofono, TRUE);
+			md->power_state = POWERED_ON;
+			return modem;
+		} else {
+			ofono_error("Error %d registering %s",
+				    err, RILMODEM_DRIVER);
+
+			/*
+			 * If ofono_modem_register() failed, then
+			 * ofono_modem_remove() won't invoke
+			 * ril_modem_remove() callback.
+			 */
+			ril_modem_remove(ofono);
+		}
+
+		ofono_modem_remove(ofono);
+	}
+
+	return NULL;
+}
+
+const struct ofono_modem_driver ril_modem_driver = {
+	.name           = RILMODEM_DRIVER,
+	.probe          = ril_modem_probe,
+	.remove         = ril_modem_remove,
+	.enable         = ril_modem_enable,
+	.disable        = ril_modem_disable,
+	.pre_sim        = ril_modem_pre_sim,
+	.post_sim       = ril_modem_post_sim,
+	.post_online    = ril_modem_post_online,
+	.set_online     = ril_modem_set_online
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_netreg.c

@@ -0,0 +1,551 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_network.h"
+#include "ril_util.h"
+#include "ril_log.h"
+
+#include "common.h"
+#include "simutil.h"
+
+enum ril_netreg_events {
+	NETREG_RIL_EVENT_NITZ_TIME_RECEIVED,
+	NETREG_RIL_EVENT_SIGNAL_STRENGTH,
+	NETREG_RIL_EVENT_COUNT
+};
+
+enum ril_netreg_network_events {
+	NETREG_NETWORK_EVENT_OPERATOR_CHANGED,
+	NETREG_NETWORK_EVENT_VOICE_STATE_CHANGED,
+	NETREG_NETWORK_EVENT_COUNT
+};
+
+struct ril_netreg {
+	GRilIoChannel *io;
+	GRilIoQueue *q;
+	struct ofono_netreg *netreg;
+	struct ril_network *network;
+	char *log_prefix;
+	guint timer_id;
+	guint notify_id;
+	guint current_operator_id;
+	gulong ril_event_id[NETREG_RIL_EVENT_COUNT];
+	gulong network_event_id[NETREG_NETWORK_EVENT_COUNT];
+};
+
+/* Defined in src/network.c */
+enum operator_status {
+	OPERATOR_STATUS_UNKNOWN =	0,
+	OPERATOR_STATUS_AVAILABLE =	1,
+	OPERATOR_STATUS_CURRENT =	2,
+	OPERATOR_STATUS_FORBIDDEN =	3,
+};
+
+struct ril_netreg_cbd {
+	struct ril_netreg *nd;
+	union {
+		ofono_netreg_status_cb_t status;
+		ofono_netreg_operator_cb_t operator;
+		ofono_netreg_operator_list_cb_t operator_list;
+		ofono_netreg_register_cb_t reg;
+		ofono_netreg_strength_cb_t strength;
+		gpointer ptr;
+	} cb;
+	gpointer data;
+};
+
+#define ril_netreg_cbd_free g_free
+
+static inline struct ril_netreg *ril_netreg_get_data(struct ofono_netreg *ofono)
+{
+	return ofono ? ofono_netreg_get_data(ofono) : NULL;
+}
+
+static struct ril_netreg_cbd *ril_netreg_cbd_new(struct ril_netreg *nd,
+						void *cb, void *data)
+{
+	struct ril_netreg_cbd *cbd = g_new0(struct ril_netreg_cbd, 1);
+
+	cbd->nd = nd;
+	cbd->cb.ptr = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+int ril_netreg_check_if_really_roaming(struct ofono_netreg *netreg,
+								gint status)
+{
+	if (status == NETWORK_REGISTRATION_STATUS_ROAMING) {
+		/* These functions tolerate NULL argument */
+		const char *net_mcc = ofono_netreg_get_mcc(netreg);
+		const char *net_mnc = ofono_netreg_get_mnc(netreg);
+		struct sim_spdi *spdi = ofono_netreg_get_spdi(netreg);
+
+		if (spdi && net_mcc && net_mnc) {
+			if (sim_spdi_lookup(spdi, net_mcc, net_mnc)) {
+				ofono_info("not roaming based on spdi");
+				return NETWORK_REGISTRATION_STATUS_REGISTERED;
+			}
+		}
+	}
+
+	return status;
+}
+
+static int ril_netreg_check_status(struct ril_netreg *nd, int status)
+{
+	return (nd && nd->netreg) ?
+		ril_netreg_check_if_really_roaming(nd->netreg, status) :
+		status;
+}
+
+static gboolean ril_netreg_status_notify_cb(gpointer user_data)
+{
+	struct ril_netreg *nd = user_data;
+	const struct ril_registration_state *reg = &nd->network->voice;
+
+	DBG("%s", nd->log_prefix);
+	GASSERT(nd->notify_id);
+	nd->notify_id = 0;
+	ofono_netreg_status_notify(nd->netreg,
+			ril_netreg_check_status(nd, reg->status),
+			reg->lac, reg->ci, reg->access_tech);
+	return FALSE;
+}
+
+static void ril_netreg_status_notify(struct ril_network *net, void *user_data)
+{
+	struct ril_netreg *nd = user_data;
+
+	/* Coalesce multiple notifications into one */
+	if (nd->notify_id) {
+		DBG("%snotification aready queued", nd->log_prefix);
+	} else {
+		DBG("%squeuing notification", nd->log_prefix);
+		nd->notify_id = g_idle_add(ril_netreg_status_notify_cb, nd);
+	}
+}
+
+static void ril_netreg_registration_status(struct ofono_netreg *netreg,
+			ofono_netreg_status_cb_t cb, void *data)
+{
+	struct ril_netreg *nd = ril_netreg_get_data(netreg);
+	const struct ril_registration_state *reg = &nd->network->voice;
+	struct ofono_error error;
+
+	DBG("%s", nd->log_prefix);
+	cb(ril_error_ok(&error),
+			ril_netreg_check_status(nd, reg->status),
+			reg->lac, reg->ci, reg->access_tech, data);
+}
+
+static gboolean ril_netreg_current_operator_cb(void *user_data)
+{
+	struct ril_netreg_cbd *cbd = user_data;
+	struct ril_netreg *nd = cbd->nd;
+	ofono_netreg_operator_cb_t cb = cbd->cb.operator;
+	struct ofono_error error;
+
+	DBG("%s", nd->log_prefix);
+	GASSERT(nd->current_operator_id);
+	nd->current_operator_id = 0;
+
+	cb(ril_error_ok(&error), nd->network->operator, cbd->data);
+	return FALSE;
+}
+
+static void ril_netreg_current_operator(struct ofono_netreg *netreg,
+				ofono_netreg_operator_cb_t cb, void *data)
+{
+	struct ril_netreg *nd = ril_netreg_get_data(netreg);
+
+	GASSERT(!nd->current_operator_id);
+	if (nd->current_operator_id) {
+		g_source_remove(nd->current_operator_id);
+	}
+
+	nd->current_operator_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
+					ril_netreg_current_operator_cb,
+					ril_netreg_cbd_new(nd, cb, data),
+					ril_netreg_cbd_free);
+}
+
+static void ril_netreg_list_operators_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_netreg_cbd *cbd = user_data;
+	ofono_netreg_operator_list_cb_t cb = cbd->cb.operator_list;
+	struct ofono_network_operator *list;
+	struct ofono_error error;
+	int noperators = 0, i;
+	GRilIoParser rilp;
+	gboolean ok = TRUE;
+
+	if (status != RIL_E_SUCCESS) {
+		ofono_error("Failed to retrive the list of operators: %s",
+						ril_error_to_string(status));
+		cb(ril_error_failure(&error), 0, NULL, cbd->data);
+		return;
+	}
+
+	grilio_parser_init(&rilp, data, len);
+
+	/* Number of operators at the list (4 strings for every operator) */
+	grilio_parser_get_int32(&rilp, &noperators);
+	GASSERT(!(noperators % 4));
+	noperators /= 4;
+	ofono_info("noperators = %d", noperators);
+
+	list = g_new0(struct ofono_network_operator, noperators);
+	for (i = 0; i < noperators && ok; i++) {
+		struct ofono_network_operator *op = list + i;
+		char *lalpha = grilio_parser_get_utf8(&rilp);
+		char *salpha = grilio_parser_get_utf8(&rilp);
+		char *numeric = grilio_parser_get_utf8(&rilp);
+		char *status = grilio_parser_get_utf8(&rilp);
+
+		/* Try to use long by default */
+		if (lalpha) {
+			strncpy(op->name, lalpha,
+					OFONO_MAX_OPERATOR_NAME_LENGTH);
+		} else if (salpha) {
+			strncpy(op->name, salpha,
+					OFONO_MAX_OPERATOR_NAME_LENGTH);
+		} else {
+			op->name[0] = 0;
+		}
+
+		/* Set the proper status  */
+		if (!strcmp(status, "available")) {
+			list[i].status = OPERATOR_STATUS_AVAILABLE;
+		} else if (!strcmp(status, "current")) {
+			list[i].status = OPERATOR_STATUS_CURRENT;
+		} else if (!strcmp(status, "forbidden")) {
+			list[i].status = OPERATOR_STATUS_FORBIDDEN;
+		} else {
+			list[i].status = OPERATOR_STATUS_UNKNOWN;
+		}
+
+		op->tech = -1;
+		ok = ril_parse_mcc_mnc(numeric, op);
+		if (ok) {
+			if (op->tech < 0) {
+				op->tech = cbd->nd->network->voice.access_tech;
+			}
+			DBG("[operator=%s, %s, %s, status: %s]", op->name,
+						op->mcc, op->mnc, status);
+		} else {
+			DBG("failed to parse operator list");
+		}
+
+		g_free(lalpha);
+		g_free(salpha);
+		g_free(numeric);
+		g_free(status);
+	}
+
+	if (ok) {
+		cb(ril_error_ok(&error), noperators, list, cbd->data);
+	} else {
+		cb(ril_error_failure(&error), 0, NULL, cbd->data);
+	}
+
+	g_free(list);
+}
+
+static void ril_netreg_list_operators(struct ofono_netreg *netreg,
+				ofono_netreg_operator_list_cb_t cb, void *data)
+{
+	struct ril_netreg *nd = ril_netreg_get_data(netreg);
+
+	grilio_queue_send_request_full(nd->q, NULL,
+			RIL_REQUEST_QUERY_AVAILABLE_NETWORKS,
+			ril_netreg_list_operators_cb, ril_netreg_cbd_free,
+			ril_netreg_cbd_new(nd, cb, data));
+}
+
+static void ril_netreg_register_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_netreg_cbd *cbd = user_data;
+	ofono_netreg_register_cb_t cb = cbd->cb.reg;
+	struct ofono_error error;
+
+	if (status == RIL_E_SUCCESS) {
+		cb(ril_error_ok(&error), cbd->data);
+	} else {
+		ofono_error("registration failed, ril result %d", status);
+		cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static void ril_netreg_register_auto(struct ofono_netreg *netreg,
+				ofono_netreg_register_cb_t cb, void *data)
+{
+	struct ril_netreg *nd = ril_netreg_get_data(netreg);
+
+	ofono_info("nw select automatic");
+	grilio_queue_send_request_full(nd->q, NULL,
+			RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC,
+			ril_netreg_register_cb, ril_netreg_cbd_free,
+			ril_netreg_cbd_new(nd, cb, data));
+}
+
+static void ril_netreg_register_manual(struct ofono_netreg *netreg,
+				const char *mcc, const char *mnc,
+				ofono_netreg_register_cb_t cb, void *data)
+{
+	struct ril_netreg *nd = ril_netreg_get_data(netreg);
+	GRilIoRequest *req = grilio_request_new();
+
+	ofono_info("nw select manual: %s%s", mcc, mnc);
+	grilio_request_append_format(req, "%s%s+0", mcc, mnc);
+	grilio_queue_send_request_full(nd->q, req,
+			RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL,
+			ril_netreg_register_cb, ril_netreg_cbd_free,
+			ril_netreg_cbd_new(nd, cb, data));
+	grilio_request_unref(req);
+}
+
+static int ril_netreg_get_signal_strength(const void *data, guint len)
+{
+	GRilIoParser rilp;
+	int gw_signal = 0, cdma_dbm = 0, evdo_dbm = 0, lte_signal = 0;
+
+	grilio_parser_init(&rilp, data, len);
+
+	/* RIL_SignalStrength_v6 */
+	/* GW_SignalStrength */
+	grilio_parser_get_int32(&rilp, &gw_signal);
+	grilio_parser_get_int32(&rilp, NULL); /* bitErrorRate */
+
+	/* CDMA_SignalStrength */
+	grilio_parser_get_int32(&rilp, &cdma_dbm);
+	grilio_parser_get_int32(&rilp, NULL); /* ecio */
+
+	/* EVDO_SignalStrength */
+	grilio_parser_get_int32(&rilp, &evdo_dbm);
+	grilio_parser_get_int32(&rilp, NULL); /* ecio */
+	grilio_parser_get_int32(&rilp, NULL); /* signalNoiseRatio */
+
+	/* LTE_SignalStrength */
+	grilio_parser_get_int32(&rilp, &lte_signal);
+	grilio_parser_get_int32(&rilp, NULL); /* rsrp */
+	grilio_parser_get_int32(&rilp, NULL); /* rsrq */
+	grilio_parser_get_int32(&rilp, NULL); /* rssnr */
+	grilio_parser_get_int32(&rilp, NULL); /* cqi */
+
+	DBG("gw: %d, cdma: %d, evdo: %d, lte: %d", gw_signal, cdma_dbm,
+							evdo_dbm, lte_signal);
+
+	/* Return the first valid one */
+	if (gw_signal != 99 && gw_signal != -1) {
+		return (gw_signal * 100) / 31;
+	}
+
+	if (lte_signal != 99 && lte_signal != -1) {
+		return (lte_signal * 100) / 31;
+	}
+
+	/* In case of dbm, return the value directly */
+	if (cdma_dbm != -1) {
+		return MIN(cdma_dbm, 100);
+	}
+
+	if (evdo_dbm != -1) {
+		return MIN(evdo_dbm, 100);
+	}
+
+	return -1;
+}
+
+static void ril_netreg_strength_notify(GRilIoChannel *io, guint ril_event,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_netreg *nd = user_data;
+	int strength;
+
+	GASSERT(ril_event == RIL_UNSOL_SIGNAL_STRENGTH);
+	strength = ril_netreg_get_signal_strength(data, len);
+	DBG("%d", strength);
+	ofono_netreg_strength_notify(nd->netreg, strength);
+}
+
+static void ril_netreg_strength_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_netreg_cbd *cbd = user_data;
+	ofono_netreg_strength_cb_t cb = cbd->cb.strength;
+	struct ofono_error error;
+
+	if (status == RIL_E_SUCCESS) {
+		int strength = ril_netreg_get_signal_strength(data, len);
+		cb(ril_error_ok(&error), strength, cbd->data);
+	} else {
+		ofono_error("Failed to retrive the signal strength: %s",
+						ril_error_to_string(status));
+		cb(ril_error_failure(&error), -1, cbd->data);
+	}
+}
+
+static void ril_netreg_strength(struct ofono_netreg *netreg,
+				ofono_netreg_strength_cb_t cb, void *data)
+{
+	struct ril_netreg *nd = ril_netreg_get_data(netreg);
+
+	grilio_queue_send_request_full(nd->q, NULL,
+			RIL_REQUEST_SIGNAL_STRENGTH, ril_netreg_strength_cb,
+			ril_netreg_cbd_free, ril_netreg_cbd_new(nd, cb, data));
+}
+
+static void ril_netreg_nitz_notify(GRilIoChannel *io, guint ril_event,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_netreg *nd = user_data;
+	GRilIoParser rilp;
+	struct ofono_network_time time;
+	int year, mon, mday, hour, min, sec, dst, tzi;
+	char tzs, tz[4];
+	gchar *nitz;
+
+	GASSERT(ril_event == RIL_UNSOL_NITZ_TIME_RECEIVED);
+
+	grilio_parser_init(&rilp, data, len);
+	nitz = grilio_parser_get_utf8(&rilp);
+
+	DBG("%s", nitz);
+	sscanf(nitz, "%u/%u/%u,%u:%u:%u%c%u,%u", &year, &mon, &mday,
+			&hour, &min, &sec, &tzs, &tzi, &dst);
+	snprintf(tz, sizeof(tz), "%c%d", tzs, tzi);
+
+	time.utcoff = atoi(tz) * 15 * 60;
+	time.dst = dst;
+	time.sec = sec;
+	time.min = min;
+	time.hour = hour;
+	time.mday = mday;
+	time.mon = mon;
+	time.year = 2000 + year;
+
+	ofono_netreg_time_notify(nd->netreg, &time);
+	g_free(nitz);
+}
+
+static gboolean ril_netreg_register(gpointer user_data)
+{
+	struct ril_netreg *nd = user_data;
+
+	GASSERT(nd->timer_id);
+	nd->timer_id = 0;
+	ofono_netreg_register(nd->netreg);
+
+	/* Register for network state changes */
+	nd->network_event_id[NETREG_NETWORK_EVENT_OPERATOR_CHANGED] =
+		ril_network_add_operator_changed_handler(nd->network,
+			ril_netreg_status_notify, nd);
+	nd->network_event_id[NETREG_NETWORK_EVENT_VOICE_STATE_CHANGED] =
+		ril_network_add_voice_state_changed_handler(nd->network,
+			ril_netreg_status_notify, nd);
+
+	/* Register for network time updates */
+	nd->ril_event_id[NETREG_RIL_EVENT_NITZ_TIME_RECEIVED] =
+		grilio_channel_add_unsol_event_handler(nd->io,
+			ril_netreg_nitz_notify, 
+			RIL_UNSOL_NITZ_TIME_RECEIVED, nd);
+
+	/* Register for signal strength changes */
+	nd->ril_event_id[NETREG_RIL_EVENT_SIGNAL_STRENGTH] =
+		grilio_channel_add_unsol_event_handler(nd->io,
+			ril_netreg_strength_notify,
+			RIL_UNSOL_SIGNAL_STRENGTH, nd);
+
+	/* This makes the timeout a single-shot */
+	return FALSE;
+}
+
+static int ril_netreg_probe(struct ofono_netreg *netreg, unsigned int vendor,
+				void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_netreg *nd = g_new0(struct ril_netreg, 1);
+	guint slot = ril_modem_slot(modem);
+
+	DBG("[%u] %p", slot, netreg);
+	nd->log_prefix = g_strdup_printf("%s_%u ", RILMODEM_DRIVER, slot);
+	nd->io = grilio_channel_ref(ril_modem_io(modem));
+	nd->q = grilio_queue_new(nd->io);
+	nd->network = ril_network_ref(modem->network);
+	nd->netreg = netreg;
+
+	ofono_netreg_set_data(netreg, nd);
+	nd->timer_id = g_idle_add(ril_netreg_register, nd);
+	return 0;
+}
+
+static void ril_netreg_remove(struct ofono_netreg *netreg)
+{
+	struct ril_netreg *nd = ril_netreg_get_data(netreg);
+	int i;
+
+	DBG("%p", netreg);
+	grilio_queue_cancel_all(nd->q, FALSE);
+	ofono_netreg_set_data(netreg, NULL);
+
+	if (nd->timer_id > 0) {
+		g_source_remove(nd->timer_id);
+	}
+
+	if (nd->notify_id) {
+		g_source_remove(nd->notify_id);
+	}
+
+	if (nd->current_operator_id) {
+		g_source_remove(nd->current_operator_id);
+	}
+
+	for (i=0; i<G_N_ELEMENTS(nd->network_event_id); i++) {
+		ril_network_remove_handler(nd->network, nd->network_event_id[i]);
+	}
+	ril_network_unref(nd->network);
+
+	grilio_channel_remove_handlers(nd->io, nd->ril_event_id,
+						G_N_ELEMENTS(nd->ril_event_id));
+
+	grilio_channel_unref(nd->io);
+	grilio_queue_unref(nd->q);
+	g_free(nd->log_prefix);
+	g_free(nd);
+}
+
+const struct ofono_netreg_driver ril_netreg_driver = {
+	.name                   = RILMODEM_DRIVER,
+	.probe                  = ril_netreg_probe,
+	.remove                 = ril_netreg_remove,
+	.registration_status    = ril_netreg_registration_status,
+	.current_operator       = ril_netreg_current_operator,
+	.list_operators         = ril_netreg_list_operators,
+	.register_auto          = ril_netreg_register_auto,
+	.register_manual        = ril_netreg_register_manual,
+	.strength               = ril_netreg_strength
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_network.c

@@ -0,0 +1,501 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_network.h"
+#include "ril_radio.h"
+#include "ril_util.h"
+#include "ril_log.h"
+
+#include <grilio_queue.h>
+#include <grilio_request.h>
+#include <grilio_parser.h>
+
+#include <ofono/netreg.h>
+#include "common.h"
+
+typedef GObjectClass RilNetworkClass;
+typedef struct ril_network RilNetwork;
+
+struct ril_network_priv {
+	GRilIoChannel *io;
+	GRilIoQueue *q;
+	struct ril_radio *radio;
+	char *log_prefix;
+	gulong event_id;
+	guint operator_poll_id;
+	guint voice_poll_id;
+	guint data_poll_id;
+	gulong radio_event_id;
+	struct ofono_network_operator operator;
+};
+
+enum ril_network_signal {
+	SIGNAL_OPERATOR_CHANGED,
+	SIGNAL_VOICE_STATE_CHANGED,
+	SIGNAL_DATA_STATE_CHANGED,
+	SIGNAL_COUNT
+};
+
+#define SIGNAL_OPERATOR_CHANGED_NAME    "ril-network-operator-changed"
+#define SIGNAL_VOICE_STATE_CHANGED_NAME "ril-network-voice-state-changed"
+#define SIGNAL_DATA_STATE_CHANGED_NAME  "ril-network-data-state-changed"
+
+static guint ril_network_signals[SIGNAL_COUNT] = { 0 };
+
+G_DEFINE_TYPE(RilNetwork, ril_network, G_TYPE_OBJECT)
+#define RIL_NETWORK_TYPE (ril_network_get_type())
+#define RIL_NETWORK(obj) (G_TYPE_CHECK_INSTANCE_CAST(obj,\
+        RIL_NETWORK_TYPE,RilNetwork))
+
+static void ril_network_reset_state(struct ril_registration_state *reg)
+{
+	memset(reg, 0, sizeof(*reg));
+	reg->status = NETWORK_REGISTRATION_STATUS_UNKNOWN;
+	reg->access_tech = -1;
+	reg->ril_tech = -1;
+	reg->lac = -1;
+	reg->ci = -1;
+}
+
+static gboolean ril_network_parse_response(struct ril_network *self,
+	const void *data, guint len, struct ril_registration_state *reg)
+{
+	struct ril_network_priv *priv = self->priv;
+	int nparams, ril_status;
+	gchar *sstatus = NULL, *slac = NULL, *sci = NULL;
+	gchar *stech = NULL, *sreason = NULL, *smax = NULL;
+	GRilIoParser rilp;
+
+	ril_network_reset_state(reg);
+
+	/* Size of response string array. The minimum seen in the wild is 3 */
+	grilio_parser_init(&rilp, data, len);
+	if (!grilio_parser_get_int32(&rilp, &nparams) || nparams < 3) {
+		DBG("%sbroken response", priv->log_prefix);
+		return FALSE;
+	}
+
+	sstatus = grilio_parser_get_utf8(&rilp);              /* response[0] */
+	if (!sstatus) {
+		DBG("%sNo sstatus value returned!", priv->log_prefix);
+		return FALSE;
+	}
+
+	slac = grilio_parser_get_utf8(&rilp);                 /* response[1] */
+	sci = grilio_parser_get_utf8(&rilp);                  /* response[2] */
+
+	if (nparams > 3) {
+		stech = grilio_parser_get_utf8(&rilp);        /* response[3] */
+	}
+
+	ril_status = atoi(sstatus);
+	if (ril_status > 10) {
+		reg->status = ril_status - 10;
+	} else {
+		reg->status = ril_status;
+	}
+
+	/* FIXME: need to review VOICE_REGISTRATION response
+	 * as it returns up to 15 parameters ( vs. 6 for DATA ).
+	 *
+	 * The first four parameters are the same for both
+	 * responses ( although status includes values for
+	 * emergency calls for VOICE response ).
+	 *
+	 * Parameters 5 & 6 have different meanings for
+	 * voice & data response.
+	 */
+	if (nparams > 4) {
+		/* TODO: different use for CDMA */
+		sreason = grilio_parser_get_utf8(&rilp);      /* response[4] */
+		if (nparams > 5) {
+			/* TODO: different use for CDMA */
+			smax = grilio_parser_get_utf8(&rilp); /* response[5] */
+			if (smax) {
+				reg->max_calls = atoi(smax);
+			}
+		}
+	}
+
+	/*
+	 * Some older RILs don't provide max calls, in that case let's
+	 * supply some reasonable default. We don't need more than 2
+	 * simultaneous data calls anyway.
+	 */
+	if (nparams <= 5) {
+		reg->max_calls = 2;
+	}
+
+	reg->lac = slac ? strtol(slac, NULL, 16) : -1;
+	reg->ci = sci ? strtol(sci, NULL, 16) : -1;
+	reg->access_tech = ril_parse_tech(stech, &reg->ril_tech);
+
+	DBG("%s%s,%s,%s,%d,%s,%s,%s", priv->log_prefix,
+				registration_status_to_string(reg->status),
+				slac, sci, reg->ril_tech,
+				registration_tech_to_string(reg->access_tech),
+				sreason, smax);
+
+	g_free(sstatus);
+	g_free(slac);
+	g_free(sci);
+	g_free(stech);
+	g_free(sreason);
+	g_free(smax);
+	return TRUE;
+}
+
+static void ril_network_op_copy(struct ofono_network_operator *dest,
+				const struct ofono_network_operator *src)
+{
+	strncpy(dest->mcc, src->mcc, sizeof(dest->mcc));
+	strncpy(dest->mnc, src->mnc, sizeof(dest->mnc));
+	strncpy(dest->name, src->name, sizeof(dest->name));
+	dest->mcc[sizeof(dest->mcc)-1] = 0;
+	dest->mnc[sizeof(dest->mnc)-1] = 0;
+	dest->name[sizeof(dest->name)-1] = 0;
+	dest->status = src->status;
+	dest->tech = src->tech;
+}
+
+static gboolean ril_network_op_equal(const struct ofono_network_operator *op1,
+				const struct ofono_network_operator *op2)
+{
+	if (op1 == op2) {
+		return TRUE;
+	} else if (!op1 || !op2) {
+		return FALSE;
+	} else {
+		return op1->status == op2->status &&
+			op1->tech == op2->tech &&
+			!strncmp(op1->mcc, op2->mcc, sizeof(op2->mcc)) &&
+			!strncmp(op1->mnc, op2->mnc, sizeof(op2->mnc)) &&
+			!strncmp(op1->name, op2->name, sizeof(op2->name));
+	}
+}
+
+static void ril_network_poll_operator_cb(GRilIoChannel *io, int req_status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_network *self = RIL_NETWORK(user_data);
+	struct ril_network_priv *priv = self->priv;
+
+	GASSERT(priv->operator_poll_id);
+	priv->operator_poll_id = 0;
+
+	if (req_status == RIL_E_SUCCESS) {
+		struct ofono_network_operator op;
+		gboolean changed = FALSE;
+		gchar *lalpha;
+		char *salpha;
+		char *numeric;
+		GRilIoParser rilp;
+
+		grilio_parser_init(&rilp, data, len);
+		grilio_parser_get_int32(&rilp, NULL);
+		lalpha = grilio_parser_get_utf8(&rilp);
+		salpha = grilio_parser_get_utf8(&rilp);
+		numeric = grilio_parser_get_utf8(&rilp);
+
+		op.tech = -1;
+		if (ril_parse_mcc_mnc(numeric, &op)) {
+			if (op.tech < 0) op.tech = self->voice.access_tech;
+			op.status = self->voice.status;
+			op.name[0] = 0;
+			if (lalpha) {
+				strncpy(op.name, lalpha, sizeof(op.name));
+			} else if (salpha) {
+				strncpy(op.name, salpha, sizeof(op.name));
+			} else {
+				strncpy(op.name, numeric, sizeof(op.name));
+			}
+			op.name[sizeof(op.name)-1] = 0;
+			if (!self->operator) {
+				self->operator = &priv->operator;
+				ril_network_op_copy(&priv->operator, &op);
+				changed = TRUE;
+			} else if (!ril_network_op_equal(&op, &priv->operator)) {
+				ril_network_op_copy(&priv->operator, &op);
+				changed = TRUE;
+			}
+		} else if (self->operator) {
+			self->operator = NULL;
+			changed = TRUE;
+		}
+
+		if (changed) {
+			if (self->operator) {
+				DBG("%slalpha=%s, salpha=%s, numeric=%s, %s, "
+					"mcc=%s, mnc=%s, %s", priv->log_prefix,
+					lalpha, salpha, numeric,
+					op.name, op.mcc, op.mnc,
+					registration_tech_to_string(op.tech));
+			} else {
+				DBG("%sno operator", priv->log_prefix);
+			}
+			g_signal_emit(self, ril_network_signals[
+					SIGNAL_OPERATOR_CHANGED], 0);
+		}
+
+		g_free(lalpha);
+		g_free(salpha);
+		g_free(numeric);
+	}
+}
+
+static void ril_network_poll_voice_state_cb(GRilIoChannel *io, int req_status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_network *self = RIL_NETWORK(user_data);
+	struct ril_network_priv *priv = self->priv;
+
+	GASSERT(priv->voice_poll_id);
+	priv->voice_poll_id = 0;
+
+	if (req_status == RIL_E_SUCCESS) {
+		struct ril_registration_state state;
+
+		ril_network_parse_response(self, data, len, &state);
+		if (memcmp(&state, &self->voice, sizeof(state))) {
+			DBG("%svoice registration changed", priv->log_prefix);
+			self->voice = state;
+			g_signal_emit(self, ril_network_signals[
+					SIGNAL_VOICE_STATE_CHANGED], 0);
+		}
+	}
+}
+
+static void ril_network_poll_data_state_cb(GRilIoChannel *io, int req_status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_network *self = RIL_NETWORK(user_data);
+	struct ril_network_priv *priv = self->priv;
+
+	GASSERT(priv->data_poll_id);
+	priv->data_poll_id = 0;
+
+	if (req_status == RIL_E_SUCCESS) {
+		struct ril_registration_state state;
+
+		ril_network_parse_response(self, data, len, &state);
+		if (memcmp(&state, &self->data, sizeof(state))) {
+			DBG("%sdata registration changed", priv->log_prefix);
+			self->data = state;
+			g_signal_emit(self, ril_network_signals[
+					SIGNAL_DATA_STATE_CHANGED], 0);
+		}
+	}
+}
+
+static guint ril_network_poll_and_retry(struct ril_network *self, guint id,
+					int code, GRilIoChannelResponseFunc fn)
+{
+	struct ril_network_priv *priv = self->priv;
+
+	if (id) {
+		/* Retry right away, don't wait for retry timeout to expire */
+		grilio_channel_retry_request(priv->io, id);
+	} else {
+		GRilIoRequest *req = grilio_request_new();
+
+		grilio_request_set_retry(req, RIL_RETRY_SECS*1000, -1);
+		id = grilio_queue_send_request_full(priv->q, req, code, fn,
+								NULL, self);
+		grilio_request_unref(req);
+	}
+
+	return id;
+}
+
+static void ril_network_poll_state(struct ril_network *self)
+{
+	struct ril_network_priv *priv = self->priv;
+
+	DBG("%s", priv->log_prefix);
+	priv->operator_poll_id = ril_network_poll_and_retry(self,
+		priv->operator_poll_id, RIL_REQUEST_OPERATOR,
+		ril_network_poll_operator_cb);
+	priv->voice_poll_id = ril_network_poll_and_retry(self,
+		priv->voice_poll_id, RIL_REQUEST_VOICE_REGISTRATION_STATE,
+		ril_network_poll_voice_state_cb);
+	priv->data_poll_id = ril_network_poll_and_retry(self,
+		priv->data_poll_id, RIL_REQUEST_DATA_REGISTRATION_STATE,
+		ril_network_poll_data_state_cb);
+}
+
+gulong ril_network_add_operator_changed_handler(struct ril_network *self,
+					ril_network_cb_t cb, void *arg)
+{
+	return (G_LIKELY(self) && G_LIKELY(cb)) ? g_signal_connect(self,
+		SIGNAL_OPERATOR_CHANGED_NAME, G_CALLBACK(cb), arg) : 0;
+}
+
+gulong ril_network_add_voice_state_changed_handler(struct ril_network *self,
+					ril_network_cb_t cb, void *arg)
+{
+	return (G_LIKELY(self) && G_LIKELY(cb)) ? g_signal_connect(self,
+		SIGNAL_VOICE_STATE_CHANGED_NAME, G_CALLBACK(cb), arg) : 0;
+}
+
+gulong ril_network_add_data_state_changed_handler(struct ril_network *self,
+					ril_network_cb_t cb, void *arg)
+{
+	return (G_LIKELY(self) && G_LIKELY(cb)) ? g_signal_connect(self,
+		SIGNAL_DATA_STATE_CHANGED_NAME, G_CALLBACK(cb), arg) : 0;
+}
+
+void ril_network_remove_handler(struct ril_network *self, gulong id)
+{
+	if (G_LIKELY(self) && G_LIKELY(id)) {
+		g_signal_handler_disconnect(self, id);
+	}
+}
+
+static void ril_network_voice_state_changed_cb(GRilIoChannel *io, guint code,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_network *self = RIL_NETWORK(user_data);
+	struct ril_network_priv *priv = self->priv;
+
+	DBG("%s", priv->log_prefix);
+	GASSERT(code == RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED);
+	ril_network_poll_state(self);
+}
+
+static void ril_network_radio_state_cb(struct ril_radio *radio, void *user_data)
+{
+	struct ril_network *self = RIL_NETWORK(user_data);
+
+	if (radio->state == RADIO_STATE_ON) {
+		ril_network_poll_state(self);
+	}
+}
+
+struct ril_network *ril_network_new(GRilIoChannel *io, struct ril_radio *radio)
+{
+	struct ril_network *self = g_object_new(RIL_NETWORK_TYPE, NULL);
+	struct ril_network_priv *priv = self->priv;
+
+	priv->io = grilio_channel_ref(io);
+	priv->q = grilio_queue_new(priv->io);
+	priv->radio = ril_radio_ref(radio);
+	priv->log_prefix =
+		(io && io->name && io->name[0] && strcmp(io->name, "RIL")) ?
+		g_strconcat(io->name, " ", NULL) : g_strdup("");
+	DBG("%s", priv->log_prefix);
+	priv->event_id = grilio_channel_add_unsol_event_handler(priv->io,
+			ril_network_voice_state_changed_cb,
+			RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, self);
+	priv->radio_event_id = ril_radio_add_state_changed_handler(priv->radio,
+		ril_network_radio_state_cb, self);
+
+	/*
+	 * Query the initial state. Querying network state before the radio
+	 * has been turned on makes RIL unhappy.
+	 */
+	if (radio->state == RADIO_STATE_ON) {
+		ril_network_poll_state(self);
+	}
+
+	return self;
+}
+
+struct ril_network *ril_network_ref(struct ril_network *self)
+{
+	if (G_LIKELY(self)) {
+		g_object_ref(RIL_NETWORK(self));
+		return self;
+	} else {
+		return NULL;
+	}
+}
+
+void ril_network_unref(struct ril_network *self)
+{
+	if (G_LIKELY(self)) {
+		g_object_unref(RIL_NETWORK(self));
+	}
+}
+
+static void ril_network_init(struct ril_network *self)
+{
+	struct ril_network_priv *priv = G_TYPE_INSTANCE_GET_PRIVATE(self,
+		RIL_NETWORK_TYPE, struct ril_network_priv);
+
+	self->priv = priv;
+	ril_network_reset_state(&self->voice);
+	ril_network_reset_state(&self->data);
+}
+
+static void ril_network_dispose(GObject *object)
+{
+	struct ril_network *self = RIL_NETWORK(object);
+	struct ril_network_priv *priv = self->priv;
+
+	if (priv->event_id) {
+		grilio_channel_remove_handler(priv->io, priv->event_id);
+		priv->event_id = 0;
+	}
+
+	if (priv->radio_event_id) {
+		ril_radio_remove_handler(priv->radio, priv->radio_event_id);
+		priv->radio_event_id = 0;
+	}
+
+	grilio_queue_cancel_all(priv->q, FALSE);
+	G_OBJECT_CLASS(ril_network_parent_class)->dispose(object);
+}
+
+static void ril_network_finalize(GObject *object)
+{
+	struct ril_network *self = RIL_NETWORK(object);
+	struct ril_network_priv *priv = self->priv;
+
+	DBG("%s", priv->log_prefix);
+	g_free(priv->log_prefix);
+	grilio_channel_unref(priv->io);
+	grilio_queue_unref(priv->q);
+	ril_radio_unref(priv->radio);
+	G_OBJECT_CLASS(ril_network_parent_class)->finalize(object);
+}
+
+static void ril_network_class_init(RilNetworkClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS(klass);
+
+	object_class->dispose = ril_network_dispose;
+	object_class->finalize = ril_network_finalize;
+	g_type_class_add_private(klass, sizeof(struct ril_network_priv));
+	ril_network_signals[SIGNAL_OPERATOR_CHANGED] =
+		g_signal_new(SIGNAL_OPERATOR_CHANGED_NAME,
+			G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
+			0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+	ril_network_signals[SIGNAL_VOICE_STATE_CHANGED] =
+		g_signal_new(SIGNAL_VOICE_STATE_CHANGED_NAME,
+			G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
+			0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+	ril_network_signals[SIGNAL_DATA_STATE_CHANGED] =
+		g_signal_new(SIGNAL_DATA_STATE_CHANGED_NAME,
+			G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
+			0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+}
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_network.h

@@ -0,0 +1,62 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#ifndef RIL_NETWORK_H
+#define RIL_NETWORK_H
+
+#include "ril_types.h"
+
+struct ofono_network_operator;
+
+struct ril_registration_state {
+	int status;        /* enum network_registration_status */
+	int access_tech;   /* enum access_technology or -1 if none */
+	int ril_tech;
+	int max_calls;
+	int lac;
+	int ci;
+};
+
+struct ril_network {
+	GObject object;
+	struct ril_network_priv *priv;
+	struct ril_registration_state voice;
+	struct ril_registration_state data;
+	const struct ofono_network_operator *operator;
+};
+
+typedef void (*ril_network_cb_t)(struct ril_network *net, void *arg);
+
+struct ril_network *ril_network_new(GRilIoChannel *io, struct ril_radio *radio);
+struct ril_network *ril_network_ref(struct ril_network *net);
+void ril_network_unref(struct ril_network *net);
+
+gulong ril_network_add_operator_changed_handler(struct ril_network *net,
+					ril_network_cb_t cb, void *arg);
+gulong ril_network_add_voice_state_changed_handler(struct ril_network *net,
+					ril_network_cb_t cb, void *arg);
+gulong ril_network_add_data_state_changed_handler(struct ril_network *net,
+					ril_network_cb_t cb, void *arg);
+void ril_network_remove_handler(struct ril_network *net, gulong id);
+
+#endif /* RIL_NETWORK */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_oem_raw.c

@@ -0,0 +1,137 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_util.h"
+#include "ril_log.h"
+#include "ril_constants.h"
+
+struct ril_oem_raw {
+	GRilIoQueue *q;
+	guint timer_id;
+};
+
+struct ril_oem_raw_cbd {
+	ofono_oem_raw_query_cb_t cb;
+	gpointer data;
+};
+
+#define ril_oem_raw_cbd_free g_free
+
+static inline struct ril_oem_raw *ril_oem_raw_get_data(
+						struct ofono_oem_raw *raw)
+{
+	return ofono_oem_raw_get_data(raw);
+}
+
+static struct ril_oem_raw_cbd *ril_oem_raw_cbd_new(ofono_oem_raw_query_cb_t cb,
+								void *data)
+{
+	struct ril_oem_raw_cbd *cbd = g_new0(struct ril_oem_raw_cbd, 1);
+
+	cbd->cb = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+static void ril_oem_raw_request_cb(GRilIoChannel *io, int status,
+			const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_oem_raw_cbd *cbd = user_data;
+
+	if (status == RIL_E_SUCCESS) {
+		struct ofono_oem_raw_results result;
+
+		result.data = (void *)data;
+		result.length = len;
+		cbd->cb(ril_error_ok(&error), &result, cbd->data);
+	} else {
+		DBG("error:%d len:%d ", status, len);
+		cbd->cb(ril_error_failure(&error), NULL, cbd->data);
+	}
+}
+
+static void ril_oem_raw_request(struct ofono_oem_raw *raw,
+			       const struct ofono_oem_raw_request *request,
+			       ofono_oem_raw_query_cb_t cb, void *data)
+{
+	struct ril_oem_raw *od = ril_oem_raw_get_data(raw);
+	GRilIoRequest *req = grilio_request_sized_new(request->length);
+
+	grilio_request_append_bytes(req, request->data, request->length);
+	grilio_queue_send_request_full(od->q, req, RIL_REQUEST_OEM_HOOK_RAW,
+				ril_oem_raw_request_cb, ril_oem_raw_cbd_free,
+				ril_oem_raw_cbd_new(cb, data));
+	grilio_request_unref(req);
+}
+
+static gboolean ril_oem_raw_register(gpointer user_data)
+{
+	struct ofono_oem_raw *raw = user_data;
+	struct ril_oem_raw *od = ril_oem_raw_get_data(raw);
+
+	DBG("");
+	GASSERT(od->timer_id);
+	od->timer_id = 0;
+	ofono_oem_raw_dbus_register(raw);
+
+	/* Single-shot */
+	return FALSE;
+}
+
+static int ril_oem_raw_probe(struct ofono_oem_raw *raw, unsigned int vendor,
+								void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_oem_raw *od = g_new0(struct ril_oem_raw, 1);
+
+	DBG("");
+	od->q = grilio_queue_new(ril_modem_io(modem));
+	od->timer_id = g_idle_add(ril_oem_raw_register, raw);
+	ofono_oem_raw_set_data(raw, od);
+	return 0;
+}
+
+static void ril_oem_raw_remove(struct ofono_oem_raw *raw)
+{
+	struct ril_oem_raw *od = ril_oem_raw_get_data(raw);
+
+	DBG("");
+	grilio_queue_cancel_all(od->q, TRUE);
+	ofono_oem_raw_set_data(raw, NULL);
+
+	if (od->timer_id) {
+		g_source_remove(od->timer_id);
+	}
+
+	grilio_queue_unref(od->q);
+	g_free(od);
+}
+
+/* const */ struct ofono_oem_raw_driver ril_oem_raw_driver = {
+	.name           = RILMODEM_DRIVER,
+	.probe          = ril_oem_raw_probe,
+	.remove         = ril_oem_raw_remove,
+	.request        = ril_oem_raw_request,
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_plugin.h

@@ -0,0 +1,167 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#ifndef RIL_PLUGIN_H
+#define RIL_PLUGIN_H
+
+#include "ril_types.h"
+
+#include <ofono/modem.h>
+#include <ofono/call-barring.h>
+#include <ofono/call-forwarding.h>
+#include <ofono/call-settings.h>
+#include <ofono/call-volume.h>
+#include <ofono/cbs.h>
+#include <ofono/devinfo.h>
+#include <ofono/gprs-context.h>
+#include <ofono/gprs.h>
+#include <ofono/netreg.h>
+#include <ofono/oemraw.h>
+#include <ofono/phonebook.h>
+#include <ofono/radio-settings.h>
+#include <ofono/sim.h>
+#include <ofono/sms.h>
+#include <ofono/stk.h>
+#include <ofono/ussd.h>
+#include <ofono/voicecall.h>
+
+#include <grilio_queue.h>
+#include <grilio_request.h>
+#include <grilio_parser.h>
+
+#define RILMODEM_DRIVER         "ril"
+
+typedef struct ril_slot_info const *ril_slot_info_ptr;
+
+struct ril_slot_config {
+	guint slot;
+	gboolean enable_4g;
+	const char *default_name;
+};
+
+struct ril_slot_info {
+	const char *path;
+	const char *imei;
+	gboolean enabled;
+	gboolean sim_present;
+	const struct ril_slot_config *config;
+};
+
+struct ril_plugin {
+	const char *default_voice_imsi;
+	const char *default_data_imsi;
+	const char *default_voice_path;
+	const char *default_data_path;
+	const ril_slot_info_ptr *slots;
+};
+
+struct ril_modem {
+	GRilIoChannel *io;
+	const char *imei;
+	struct ofono_modem *ofono;
+	struct ril_radio *radio;
+	struct ril_data *data;
+	struct ril_network *network;
+	struct ril_sim_card *sim_card;
+	struct ril_slot_config config;
+};
+
+#define RIL_PLUGIN_SIGNAL_VOICE_IMSI    (0x01)
+#define RIL_PLUGIN_SIGNAL_DATA_IMSI     (0x02)
+#define RIL_PLUGIN_SIGNAL_VOICE_PATH    (0x04)
+#define RIL_PLUGIN_SIGNAL_DATA_PATH     (0x10)
+#define RIL_PLUGIN_SIGNAL_ENABLED_SLOTS (0x20)
+
+typedef void (*ril_modem_cb_t)(struct ril_modem *modem, void *data);
+
+void ril_plugin_set_enabled_slots(struct ril_plugin *plugin, char **slots);
+void ril_plugin_set_default_voice_imsi(struct ril_plugin *plugin,
+							const char *imsi);
+void ril_plugin_set_default_data_imsi(struct ril_plugin *plugin,
+							const char *imsi);
+
+struct ril_sim_dbus *ril_sim_dbus_new(struct ril_modem *modem);
+const char *ril_sim_dbus_imsi(struct ril_sim_dbus *dbus);
+void ril_sim_dbus_free(struct ril_sim_dbus *dbus);
+
+struct ril_plugin_dbus *ril_plugin_dbus_new(struct ril_plugin *plugin);
+void ril_plugin_dbus_free(struct ril_plugin_dbus *dbus);
+void ril_plugin_dbus_block_imei_requests(struct ril_plugin_dbus *dbus,
+							gboolean clock);
+void ril_plugin_dbus_signal(struct ril_plugin_dbus *dbus, int mask);
+void ril_plugin_dbus_signal_sim(struct ril_plugin_dbus *dbus, int index,
+							gboolean present);
+
+struct ril_modem *ril_modem_create(GRilIoChannel *io,
+		const struct ril_slot_info *slot, struct ril_radio *radio,
+		struct ril_network *network, struct ril_sim_card *card,
+		struct ril_data *data);
+void ril_modem_delete(struct ril_modem *modem);
+void ril_modem_set_imei(struct ril_modem *modem, const char *imei);
+struct ofono_sim *ril_modem_ofono_sim(struct ril_modem *modem);
+struct ofono_gprs *ril_modem_ofono_gprs(struct ril_modem *modem);
+struct ofono_netreg *ril_modem_ofono_netreg(struct ril_modem *modem);
+void ril_modem_set_removed_cb(struct ril_modem *modem, ril_modem_cb_t cb,
+								void *data);
+
+#define ril_modem_get_path(modem) ofono_modem_get_path((modem)->ofono)
+#define ril_modem_4g_enabled(modem) ((modem)->config.enable_4g)
+#define ril_modem_slot(modem) ((modem)->config.slot)
+#define ril_modem_io(modem) ((modem)->io)
+
+void ril_sim_read_file_linear(struct ofono_sim *sim, int fileid,
+		int record, int length, const unsigned char *path,
+		unsigned int path_len, ofono_sim_read_cb_t cb, void *data);
+void ril_sim_read_file_cyclic(struct ofono_sim *sim, int fileid,
+		int record, int length, const unsigned char *path,
+		unsigned int path_len, ofono_sim_read_cb_t cb, void *data);
+void ril_sim_read_file_transparent(struct ofono_sim *sim, int fileid,
+		int start, int length, const unsigned char *path,
+		unsigned int path_len, ofono_sim_read_cb_t cb, void *data);
+void ril_sim_read_file_info(struct ofono_sim *sim, int fileid,
+		const unsigned char *path, unsigned int path_len,
+		ofono_sim_file_info_cb_t cb, void *data);
+
+int ril_sim_app_type(struct ofono_sim *sim);
+int ril_netreg_check_if_really_roaming(struct ofono_netreg *netreg, gint status);
+
+extern const struct ofono_call_barring_driver ril_call_barring_driver;
+extern const struct ofono_call_forwarding_driver ril_call_forwarding_driver;
+extern const struct ofono_call_settings_driver ril_call_settings_driver;
+extern const struct ofono_call_volume_driver ril_call_volume_driver;
+extern const struct ofono_cbs_driver ril_cbs_driver;
+extern const struct ofono_devinfo_driver ril_devinfo_driver;
+extern const struct ofono_gprs_context_driver ril_gprs_context_driver;
+extern const struct ofono_gprs_driver ril_gprs_driver;
+extern const struct ofono_modem_driver ril_modem_driver;
+extern const struct ofono_netreg_driver ril_netreg_driver;
+extern /* const */ struct ofono_oem_raw_driver ril_oem_raw_driver;
+extern const struct ofono_phonebook_driver ril_phonebook_driver;
+extern const struct ofono_radio_settings_driver ril_radio_settings_driver;
+extern const struct ofono_sim_driver ril_sim_driver;
+extern const struct ofono_sms_driver ril_sms_driver;
+extern const struct ofono_stk_driver ril_stk_driver;
+extern const struct ofono_ussd_driver ril_ussd_driver;
+extern const struct ofono_voicecall_driver ril_voicecall_driver;
+
+#endif /* RIL_PLUGIN_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_plugin_dbus.c

@@ -0,0 +1,644 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+
+#include <ofono/log.h>
+#include <ofono/dbus.h>
+
+#include <gutil_strv.h>
+#include <gutil_log.h>
+#include <gdbus.h>
+
+#include "ofono.h"
+
+typedef void (*ril_plugin_dbus_append_fn)(DBusMessageIter *it,
+					struct ril_plugin_dbus *dbus);
+typedef gboolean (*ril_plugin_dbus_slot_select_fn)
+					(const struct ril_slot_info *slot);
+typedef const char *(*ril_plugin_dbus_slot_string_fn)
+					(const struct ril_slot_info *slot);
+
+struct ril_plugin_dbus_request {
+	DBusMessage *msg;
+	ril_plugin_dbus_append_fn fn;
+};
+
+struct ril_plugin_dbus {
+	struct ril_plugin *plugin;
+	DBusConnection *conn;
+	gboolean block_imei_req;
+	GSList *blocked_imei_req;
+};
+
+#define RIL_DBUS_PATH               "/"
+#define RIL_DBUS_INTERFACE          "org.nemomobile.ofono.ModemManager"
+#define RIL_DBUS_INTERFACE_VERSION  (3)
+
+#define RIL_DBUS_ENABLED_MODEMS_CHANGED_SIGNAL      "EnabledModemsChanged"
+#define RIL_DBUS_PRESENT_SIMS_CHANGED_SIGNAL        "PresentSimsChanged"
+#define RIL_DBUS_DEFAULT_VOICE_SIM_CHANGED_SIGNAL   "DefaultVoiceSimChanged"
+#define RIL_DBUS_DEFAULT_DATA_SIM_CHANGED_SIGNAL    "DefaultDataSimChanged"
+#define RIL_DBUS_DEFAULT_VOICE_MODEM_CHANGED_SIGNAL "DefaultVoiceModemChanged"
+#define RIL_DBUS_DEFAULT_DATA_MODEM_CHANGED_SIGNAL  "DefaultDataModemChanged"
+#define RIL_DBUS_IMSI_AUTO                          "auto"
+
+static gboolean ril_plugin_dbus_enabled(const struct ril_slot_info *slot)
+{
+	return slot->enabled;
+}
+
+static gboolean ril_plugin_dbus_present(const struct ril_slot_info *slot)
+{
+	return slot->sim_present;
+}
+
+static const char *ril_plugin_dbus_imei(const struct ril_slot_info *slot)
+{
+	return slot->imei;
+}
+
+static void ril_plugin_dbus_append_path_array(DBusMessageIter *it,
+	struct ril_plugin_dbus *dbus, ril_plugin_dbus_slot_select_fn selector)
+{
+	DBusMessageIter array;
+	const struct ril_slot_info *const *ptr = dbus->plugin->slots;
+
+	dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY,
+				DBUS_TYPE_OBJECT_PATH_AS_STRING, &array);
+
+	while (*ptr) {
+		const struct ril_slot_info *slot = *ptr++;
+		if (!selector || selector(slot)) {
+			const char *path = slot->path;
+			dbus_message_iter_append_basic(&array,
+						DBUS_TYPE_OBJECT_PATH, &path);
+		}
+	}
+
+	dbus_message_iter_close_container(it, &array);
+}
+
+static void ril_plugin_dbus_append_string_array(DBusMessageIter *it,
+	struct ril_plugin_dbus *dbus, ril_plugin_dbus_slot_string_fn fn)
+{
+	DBusMessageIter array;
+	const struct ril_slot_info *const *ptr = dbus->plugin->slots;
+
+	dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY,
+				DBUS_TYPE_STRING_AS_STRING, &array);
+
+	while (*ptr) {
+		const struct ril_slot_info *slot = *ptr++;
+		const char *str = fn(slot);
+
+		if (!str) str = "";
+		dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &str);
+	}
+
+	dbus_message_iter_close_container(it, &array);
+}
+
+static void ril_plugin_dbus_append_boolean_array(DBusMessageIter *it,
+	struct ril_plugin_dbus *dbus, ril_plugin_dbus_slot_select_fn value)
+{
+	DBusMessageIter array;
+	const struct ril_slot_info *const *ptr = dbus->plugin->slots;
+
+	dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY,
+				DBUS_TYPE_BOOLEAN_AS_STRING, &array);
+
+	while (*ptr) {
+		const struct ril_slot_info *slot = *ptr++;
+		dbus_bool_t b = value(slot);
+
+		dbus_message_iter_append_basic(&array, DBUS_TYPE_BOOLEAN, &b);
+	}
+
+	dbus_message_iter_close_container(it, &array);
+}
+
+static void ril_plugin_dbus_append_imsi(DBusMessageIter *it, const char *imsi)
+{
+	if (!imsi) imsi = RIL_DBUS_IMSI_AUTO;
+	dbus_message_iter_append_basic(it, DBUS_TYPE_STRING, &imsi);
+}
+
+static void ril_plugin_dbus_append_path(DBusMessageIter *it, const char *path)
+{
+	if (!path) path = "";
+	/* It's DBUS_TYPE_STRING because DBUS_TYPE_OBJECT_PATH can't be empty */
+	dbus_message_iter_append_basic(it, DBUS_TYPE_STRING, &path);
+}
+
+static void ril_plugin_dbus_message_append_path_array(DBusMessage *msg,
+	struct ril_plugin_dbus *dbus, ril_plugin_dbus_slot_select_fn fn)
+{
+	DBusMessageIter iter;
+
+	dbus_message_iter_init_append(msg, &iter);
+	ril_plugin_dbus_append_path_array(&iter, dbus, fn);
+}
+
+static void ril_plugin_dbus_signal_path_array(struct ril_plugin_dbus *dbus,
+			const char *name, ril_plugin_dbus_slot_select_fn fn)
+{
+	DBusMessage *signal = dbus_message_new_signal(RIL_DBUS_PATH,
+						RIL_DBUS_INTERFACE, name);
+
+	ril_plugin_dbus_message_append_path_array(signal, dbus, fn);
+	g_dbus_send_message(dbus->conn, signal);
+}
+
+static inline void ril_plugin_dbus_signal_imsi(struct ril_plugin_dbus *dbus,
+				const char *name, const char *imsi)
+{
+	if (!imsi) imsi = RIL_DBUS_IMSI_AUTO;
+	g_dbus_emit_signal(dbus->conn, RIL_DBUS_PATH, RIL_DBUS_INTERFACE,
+			name, DBUS_TYPE_STRING, &imsi, DBUS_TYPE_INVALID);
+}
+
+static inline void ril_plugin_dbus_signal_path(struct ril_plugin_dbus *dbus,
+				const char *name, const char *path)
+{
+	if (!path) path = "";
+	g_dbus_emit_signal(dbus->conn, RIL_DBUS_PATH, RIL_DBUS_INTERFACE,
+			name, DBUS_TYPE_STRING, &path, DBUS_TYPE_INVALID);
+}
+
+void ril_plugin_dbus_signal(struct ril_plugin_dbus *dbus, int mask)
+{
+	if (dbus) {
+		if (mask & RIL_PLUGIN_SIGNAL_VOICE_IMSI) {
+			ril_plugin_dbus_signal_imsi(dbus,
+				RIL_DBUS_DEFAULT_VOICE_SIM_CHANGED_SIGNAL,
+				dbus->plugin->default_voice_imsi);
+		}
+		if (mask & RIL_PLUGIN_SIGNAL_DATA_IMSI) {
+			ril_plugin_dbus_signal_imsi(dbus,
+				RIL_DBUS_DEFAULT_DATA_SIM_CHANGED_SIGNAL,
+				dbus->plugin->default_data_imsi);
+		}
+		if (mask & RIL_PLUGIN_SIGNAL_ENABLED_SLOTS) {
+			ril_plugin_dbus_signal_path_array(dbus,
+				RIL_DBUS_ENABLED_MODEMS_CHANGED_SIGNAL,
+				ril_plugin_dbus_enabled);
+		}
+		if (mask & RIL_PLUGIN_SIGNAL_VOICE_PATH) {
+			ril_plugin_dbus_signal_path(dbus,
+				RIL_DBUS_DEFAULT_VOICE_MODEM_CHANGED_SIGNAL,
+				dbus->plugin->default_voice_path);
+		}
+		if (mask & RIL_PLUGIN_SIGNAL_DATA_PATH) {
+			ril_plugin_dbus_signal_path(dbus,
+				RIL_DBUS_DEFAULT_DATA_MODEM_CHANGED_SIGNAL,
+				dbus->plugin->default_data_path);
+		}
+	}
+}
+
+void ril_plugin_dbus_signal_sim(struct ril_plugin_dbus *dbus, int index,
+							gboolean present)
+{
+	dbus_bool_t value = present;
+	g_dbus_emit_signal(dbus->conn, RIL_DBUS_PATH, RIL_DBUS_INTERFACE,
+			RIL_DBUS_PRESENT_SIMS_CHANGED_SIGNAL,
+			DBUS_TYPE_INT32, &index,
+			DBUS_TYPE_BOOLEAN, &value,
+			DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *ril_plugin_dbus_reply_with_path_array(DBusMessage *msg,
+	struct ril_plugin_dbus *dbus, ril_plugin_dbus_slot_select_fn fn)
+{
+	DBusMessage *reply = dbus_message_new_method_return(msg);
+
+	ril_plugin_dbus_message_append_path_array(reply, dbus, fn);
+	return reply;
+}
+
+static DBusMessage *ril_plugin_dbus_reply(DBusMessage *msg,
+		struct ril_plugin_dbus *dbus, ril_plugin_dbus_append_fn append)
+{
+	DBusMessage *reply = dbus_message_new_method_return(msg);
+	DBusMessageIter iter;
+
+	dbus_message_iter_init_append(reply, &iter);
+	append(&iter, dbus);
+	return reply;
+}
+
+static void ril_plugin_dbus_unblock_request(gpointer data, gpointer user_data)
+{
+	struct ril_plugin_dbus_request *req = data;
+
+	DBG("unblocking IMEI request %p", req);
+	__ofono_dbus_pending_reply(&req->msg, ril_plugin_dbus_reply(req->msg,
+				(struct ril_plugin_dbus *)user_data, req->fn));
+	g_free(req);
+}
+
+static void ril_plugin_dbus_cancel_request(gpointer data)
+{
+	struct ril_plugin_dbus_request *req = data;
+
+	DBG("canceling IMEI request %p", req);
+	__ofono_dbus_pending_reply(&req->msg, __ofono_error_canceled(req->msg));
+	g_free(req);
+}
+
+void ril_plugin_dbus_block_imei_requests(struct ril_plugin_dbus *dbus,
+								gboolean block)
+{
+	dbus->block_imei_req = block;
+	if (!block && dbus->blocked_imei_req) {
+		g_slist_foreach(dbus->blocked_imei_req,
+				ril_plugin_dbus_unblock_request, dbus);
+		g_slist_free(dbus->blocked_imei_req);
+		dbus->blocked_imei_req = NULL;
+	}
+}
+
+static DBusMessage *ril_plugin_dbus_imei_reply(DBusMessage *msg,
+		struct ril_plugin_dbus *dbus, ril_plugin_dbus_append_fn fn)
+{
+	if (dbus->block_imei_req) {
+		struct ril_plugin_dbus_request *req =
+			g_new(struct ril_plugin_dbus_request, 1);
+
+		req->msg = dbus_message_ref(msg);
+		req->fn = fn;
+		dbus->blocked_imei_req = g_slist_append(dbus->blocked_imei_req,
+									req);
+		DBG("blocking IMEI request %p", req);
+		return NULL;
+	} else {
+		return ril_plugin_dbus_reply(msg, dbus, fn);
+	}
+}
+
+static void ril_plugin_dbus_append_version(DBusMessageIter *it,
+						struct ril_plugin_dbus *dbus)
+{
+	dbus_int32_t version = RIL_DBUS_INTERFACE_VERSION;
+
+	dbus_message_iter_append_basic(it, DBUS_TYPE_INT32, &version);
+}
+
+static void ril_plugin_dbus_append_all(DBusMessageIter *it,
+						struct ril_plugin_dbus *dbus)
+{
+	ril_plugin_dbus_append_version(it, dbus);
+	ril_plugin_dbus_append_path_array(it, dbus, NULL);
+	ril_plugin_dbus_append_path_array(it, dbus, ril_plugin_dbus_enabled);
+	ril_plugin_dbus_append_imsi(it, dbus->plugin->default_data_imsi);
+	ril_plugin_dbus_append_imsi(it, dbus->plugin->default_voice_imsi);
+	ril_plugin_dbus_append_path(it, dbus->plugin->default_data_path);
+	ril_plugin_dbus_append_path(it, dbus->plugin->default_voice_path);
+}
+
+static void ril_plugin_dbus_append_all2(DBusMessageIter *it,
+						struct ril_plugin_dbus *dbus)
+{
+	ril_plugin_dbus_append_all(it, dbus);
+	ril_plugin_dbus_append_boolean_array(it, dbus, ril_plugin_dbus_present);
+}
+
+static void ril_plugin_dbus_append_all3(DBusMessageIter *it,
+						struct ril_plugin_dbus *dbus)
+{
+	ril_plugin_dbus_append_all2(it, dbus);
+	ril_plugin_dbus_append_string_array(it, dbus, ril_plugin_dbus_imei);
+}
+
+static DBusMessage *ril_plugin_dbus_get_all(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return ril_plugin_dbus_reply(msg, (struct ril_plugin_dbus *)data,
+						ril_plugin_dbus_append_all);
+}
+
+static DBusMessage *ril_plugin_dbus_get_all2(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return ril_plugin_dbus_reply(msg, (struct ril_plugin_dbus *)data,
+						ril_plugin_dbus_append_all2);
+}
+
+static DBusMessage *ril_plugin_dbus_get_all3(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return ril_plugin_dbus_imei_reply(msg, (struct ril_plugin_dbus *)data,
+						ril_plugin_dbus_append_all3);
+}
+
+static DBusMessage *ril_plugin_dbus_get_interface_version(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return ril_plugin_dbus_reply(msg, (struct ril_plugin_dbus *)data,
+						ril_plugin_dbus_append_version);
+}
+
+static DBusMessage *ril_plugin_dbus_get_available_modems(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return ril_plugin_dbus_reply_with_path_array(msg,
+					(struct ril_plugin_dbus *)data, NULL);
+}
+
+static DBusMessage *ril_plugin_dbus_get_enabled_modems(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return ril_plugin_dbus_reply_with_path_array(msg,
+		(struct ril_plugin_dbus *)data, ril_plugin_dbus_enabled);
+}
+
+static void ril_plugin_dbus_append_present_sims(DBusMessageIter *it,
+						struct ril_plugin_dbus *dbus)
+{
+	ril_plugin_dbus_append_boolean_array(it, dbus, ril_plugin_dbus_present);
+}
+
+static DBusMessage *ril_plugin_dbus_get_present_sims(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return ril_plugin_dbus_reply(msg, (struct ril_plugin_dbus *)data,
+				ril_plugin_dbus_append_present_sims);
+}
+
+static void ril_plugin_dbus_append_imei_array(DBusMessageIter *it,
+						struct ril_plugin_dbus *dbus)
+{
+	ril_plugin_dbus_append_string_array(it, dbus, ril_plugin_dbus_imei);
+}
+
+static DBusMessage *ril_plugin_dbus_get_imei(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return ril_plugin_dbus_imei_reply(msg, (struct ril_plugin_dbus *)data,
+					ril_plugin_dbus_append_imei_array);
+}
+
+static DBusMessage *ril_plugin_dbus_reply_with_imsi(DBusMessage *msg,
+							const char *imsi)
+{
+	DBusMessage *reply = dbus_message_new_method_return(msg);
+	DBusMessageIter iter;
+
+	dbus_message_iter_init_append(reply, &iter);
+	ril_plugin_dbus_append_imsi(&iter, imsi);
+	return reply;
+}
+
+static DBusMessage *ril_plugin_dbus_get_default_data_sim(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	struct ril_plugin_dbus *dbus = data;
+
+	return ril_plugin_dbus_reply_with_imsi(msg,
+					dbus->plugin->default_data_imsi);
+}
+
+static DBusMessage *ril_plugin_dbus_get_default_voice_sim(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	struct ril_plugin_dbus *dbus = data;
+
+	return ril_plugin_dbus_reply_with_imsi(msg,
+					dbus->plugin->default_voice_imsi);
+}
+
+static DBusMessage *ril_plugin_dbus_reply_with_path(DBusMessage *msg,
+							const char *path)
+{
+	DBusMessage *reply = dbus_message_new_method_return(msg);
+	DBusMessageIter iter;
+
+	dbus_message_iter_init_append(reply, &iter);
+	ril_plugin_dbus_append_path(&iter, path);
+	return reply;
+}
+
+static DBusMessage *ril_plugin_dbus_get_default_data_modem(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	struct ril_plugin_dbus *dbus = data;
+
+	return ril_plugin_dbus_reply_with_path(msg,
+					dbus->plugin->default_data_path);
+}
+
+static DBusMessage *ril_plugin_dbus_get_default_voice_modem(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	struct ril_plugin_dbus *dbus = data;
+
+	return ril_plugin_dbus_reply_with_path(msg,
+					dbus->plugin->default_voice_path);
+}
+
+static DBusMessage *ril_plugin_dbus_set_enabled_modems(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	struct ril_plugin_dbus *dbus = data;
+	DBusMessageIter iter;
+
+	dbus_message_iter_init(msg, &iter);
+	if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_ARRAY) {
+		char **paths = NULL;
+		DBusMessageIter array;
+
+		dbus_message_iter_recurse(&iter, &array);
+		while (dbus_message_iter_get_arg_type(&array) ==
+						DBUS_TYPE_OBJECT_PATH) {
+			DBusBasicValue value;
+
+			dbus_message_iter_get_basic(&array, &value);
+			paths = gutil_strv_add(paths, value.str);
+			dbus_message_iter_next(&array);
+		}
+
+		ril_plugin_set_enabled_slots(dbus->plugin, paths);
+		g_strfreev(paths);
+		return dbus_message_new_method_return(msg);
+	} else {
+		return __ofono_error_invalid_args(msg);
+	}
+}
+
+static DBusMessage *ril_plugin_dbus_set_imsi(struct ril_plugin_dbus *dbus,
+		DBusMessage *msg, void (*apply)(struct ril_plugin *plugin,
+							const char *imsi))
+{
+	DBusMessageIter iter;
+
+	dbus_message_iter_init(msg, &iter);
+	if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING) {
+		DBusBasicValue value;
+		const char *imsi;
+
+		dbus_message_iter_get_basic(&iter, &value);
+		imsi = value.str;
+		if (!g_strcmp0(imsi, RIL_DBUS_IMSI_AUTO)) imsi = NULL; 
+		apply(dbus->plugin, imsi);
+		return dbus_message_new_method_return(msg);
+	} else {
+		return __ofono_error_invalid_args(msg);
+	}
+}
+
+static DBusMessage *ril_plugin_dbus_set_default_voice_sim(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	struct ril_plugin_dbus *dbus = data;
+
+	GASSERT(conn == dbus->conn);
+	return ril_plugin_dbus_set_imsi(dbus, msg,
+					ril_plugin_set_default_voice_imsi);
+}
+
+static DBusMessage *ril_plugin_dbus_set_default_data_sim(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	struct ril_plugin_dbus *dbus = data;
+
+	GASSERT(conn == dbus->conn);
+	return ril_plugin_dbus_set_imsi(dbus, msg,
+					ril_plugin_set_default_data_imsi);
+}
+
+static const GDBusMethodTable ril_plugin_dbus_methods[] = {
+	{ GDBUS_METHOD("GetAll", NULL,
+			GDBUS_ARGS({"version", "i" },
+			{"availableModems", "ao" },
+			{"enabledModems", "ao" },
+			{"defaultDataSim", "s" },
+			{"defaultVoiceSim", "s" },
+			{"defaultDataModem", "s" },
+			{"defaultVoiceModem" , "s"}),
+			ril_plugin_dbus_get_all) },
+	{ GDBUS_METHOD("GetAll2", NULL,
+			GDBUS_ARGS({"version", "i" },
+			{"availableModems", "ao" },
+			{"enabledModems", "ao" },
+			{"defaultDataSim", "s" },
+			{"defaultVoiceSim", "s" },
+			{"defaultDataModem", "s" },
+			{"defaultVoiceModem" , "s"},
+			{"presentSims" , "ab"}),
+			ril_plugin_dbus_get_all2) },
+	{ GDBUS_ASYNC_METHOD("GetAll3", NULL,
+			GDBUS_ARGS({"version", "i" },
+			{"availableModems", "ao" },
+			{"enabledModems", "ao" },
+			{"defaultDataSim", "s" },
+			{"defaultVoiceSim", "s" },
+			{"defaultDataModem", "s" },
+			{"defaultVoiceModem" , "s"},
+			{"presentSims" , "ab"},
+			{"imei" , "as"}),
+			ril_plugin_dbus_get_all3) },
+	{ GDBUS_METHOD("GetInterfaceVersion",
+			NULL, GDBUS_ARGS({ "version", "i" }),
+			ril_plugin_dbus_get_interface_version) },
+	{ GDBUS_METHOD("GetAvailableModems",
+			NULL, GDBUS_ARGS({ "modems", "ao" }),
+			ril_plugin_dbus_get_available_modems) },
+	{ GDBUS_METHOD("GetEnabledModems",
+			NULL, GDBUS_ARGS({ "modems", "ao" }),
+			ril_plugin_dbus_get_enabled_modems) },
+	{ GDBUS_METHOD("GetPresentSims",
+			NULL, GDBUS_ARGS({ "presentSims", "ab" }),
+			ril_plugin_dbus_get_present_sims) },
+	{ GDBUS_ASYNC_METHOD("GetIMEI",
+			NULL, GDBUS_ARGS({ "imei", "as" }),
+			ril_plugin_dbus_get_imei) },
+	{ GDBUS_METHOD("GetDefaultDataSim",
+			NULL, GDBUS_ARGS({ "imsi", "s" }),
+			ril_plugin_dbus_get_default_data_sim) },
+	{ GDBUS_METHOD("GetDefaultVoiceSim",
+			NULL, GDBUS_ARGS({ "imsi", "s" }),
+			ril_plugin_dbus_get_default_voice_sim) },
+	{ GDBUS_METHOD("GetDefaultDataModem",
+			NULL, GDBUS_ARGS({ "path", "s" }),
+			ril_plugin_dbus_get_default_data_modem) },
+	{ GDBUS_METHOD("GetDefaultVoiceModem",
+			NULL, GDBUS_ARGS({ "path", "s" }),
+			ril_plugin_dbus_get_default_voice_modem) },
+	{ GDBUS_METHOD("SetEnabledModems",
+			GDBUS_ARGS({ "modems", "ao" }), NULL,
+			ril_plugin_dbus_set_enabled_modems) },
+	{ GDBUS_METHOD("SetDefaultDataSim",
+			GDBUS_ARGS({ "imsi", "s" }), NULL,
+			ril_plugin_dbus_set_default_data_sim) },
+	{ GDBUS_METHOD("SetDefaultVoiceSim",
+			GDBUS_ARGS({ "imsi", "s" }), NULL,
+			ril_plugin_dbus_set_default_voice_sim) },
+	{ }
+};
+
+static const GDBusSignalTable ril_plugin_dbus_signals[] = {
+	{ GDBUS_SIGNAL(RIL_DBUS_ENABLED_MODEMS_CHANGED_SIGNAL,
+			GDBUS_ARGS({ "modems", "ao" })) },
+	{ GDBUS_SIGNAL(RIL_DBUS_PRESENT_SIMS_CHANGED_SIGNAL,
+			GDBUS_ARGS({"index", "i" },
+			{"present" , "b"})) },
+	{ GDBUS_SIGNAL(RIL_DBUS_DEFAULT_DATA_SIM_CHANGED_SIGNAL,
+			GDBUS_ARGS({ "imsi", "s" })) },
+	{ GDBUS_SIGNAL(RIL_DBUS_DEFAULT_VOICE_SIM_CHANGED_SIGNAL,
+			GDBUS_ARGS({ "imsi", "s" })) },
+	{ GDBUS_SIGNAL(RIL_DBUS_DEFAULT_DATA_MODEM_CHANGED_SIGNAL,
+			GDBUS_ARGS({ "path", "s" })) },
+	{ GDBUS_SIGNAL(RIL_DBUS_DEFAULT_VOICE_MODEM_CHANGED_SIGNAL,
+			GDBUS_ARGS({ "path", "s" })) },
+	{ }
+};
+
+struct ril_plugin_dbus *ril_plugin_dbus_new(struct ril_plugin *plugin)
+{
+	struct ril_plugin_dbus *dbus = g_new0(struct ril_plugin_dbus, 1);
+
+	dbus->conn = dbus_connection_ref(ofono_dbus_get_connection());
+	dbus->plugin = plugin;
+	if (g_dbus_register_interface(dbus->conn, RIL_DBUS_PATH,
+			RIL_DBUS_INTERFACE, ril_plugin_dbus_methods,
+			ril_plugin_dbus_signals, NULL, dbus, NULL)) {
+		return dbus;
+	} else {
+		ofono_error("RIL D-Bus register failed");
+		ril_plugin_dbus_free(dbus);
+		return NULL;
+	}
+}
+
+void ril_plugin_dbus_free(struct ril_plugin_dbus *dbus)
+{
+	if (dbus) {
+		g_slist_free_full(dbus->blocked_imei_req,
+					ril_plugin_dbus_cancel_request);
+		g_dbus_unregister_interface(dbus->conn, RIL_DBUS_PATH,
+							RIL_DBUS_INTERFACE);
+		dbus_connection_unref(dbus->conn);
+		g_free(dbus);
+	}
+}
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_radio.c

@@ -0,0 +1,405 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_radio.h"
+#include "ril_util.h"
+#include "ril_log.h"
+
+#include <grilio_queue.h>
+#include <grilio_request.h>
+#include <grilio_parser.h>
+
+typedef GObjectClass RilRadioClass;
+typedef struct ril_radio RilRadio;
+
+/*
+ * Object states:
+ *
+ * 1. Idle (!pending && !retry)
+ * 2. Power on/off request pending (pending)
+ * 3. Power on retry has been scheduled (retry)
+ */
+struct ril_radio_priv {
+	GRilIoChannel *io;
+	GRilIoQueue *q;
+	gulong state_event_id;
+	char *log_prefix;
+	GHashTable *req_table;
+	guint pending_id;
+	guint retry_id;
+	guint state_changed_while_request_pending;
+	enum ril_radio_state last_known_state;
+	gboolean power_cycle;
+	gboolean next_state_valid;
+	gboolean next_state;
+};
+
+enum ril_radio_signal {
+	SIGNAL_STATE_CHANGED,
+	SIGNAL_COUNT
+};
+
+#define POWER_RETRY_SECS (1)
+
+#define SIGNAL_STATE_CHANGED_NAME       "ril-radio-state-changed"
+
+static guint ril_radio_signals[SIGNAL_COUNT] = { 0 };
+
+G_DEFINE_TYPE(RilRadio, ril_radio, G_TYPE_OBJECT)
+#define RIL_RADIO_TYPE (ril_radio_get_type())
+#define RIL_RADIO(obj) (G_TYPE_CHECK_INSTANCE_CAST(obj,RIL_RADIO_TYPE,RilRadio))
+
+static void ril_radio_submit_power_request(struct ril_radio *self, gboolean on);
+
+G_INLINE_FUNC gboolean ril_radio_power_should_be_on(struct ril_radio *self)
+{
+	struct ril_radio_priv *priv = self->priv;
+
+	return g_hash_table_size(priv->req_table) && !priv->power_cycle;
+}
+
+G_INLINE_FUNC gboolean ril_radio_state_off(enum ril_radio_state radio_state)
+{
+	return radio_state == RADIO_STATE_OFF;
+}
+
+G_INLINE_FUNC gboolean ril_radio_state_on(enum ril_radio_state radio_state)
+{
+	return !ril_radio_state_off(radio_state);
+}
+
+static gboolean ril_radio_power_request_retry_cb(gpointer user_data)
+{
+	struct ril_radio *self = user_data;
+	struct ril_radio_priv *priv = self->priv;
+
+	DBG("%s", priv->log_prefix);
+	GASSERT(priv->retry_id);
+	priv->retry_id = 0;
+	ril_radio_submit_power_request(self, ril_radio_power_should_be_on(self));
+	return FALSE;
+}
+
+static void ril_radio_cancel_retry(struct ril_radio *self)
+{
+	struct ril_radio_priv *priv = self->priv;
+
+	if (priv->retry_id) {
+		DBG("%sretry cancelled", priv->log_prefix);
+		g_source_remove(priv->retry_id);
+		priv->retry_id = 0;
+	}
+}
+
+static void ril_radio_check_state(struct ril_radio *self)
+{
+	struct ril_radio_priv *priv = self->priv;
+
+	if (!priv->pending_id) {
+		const gboolean should_be_on = ril_radio_power_should_be_on(self);
+
+		if (ril_radio_state_on(self->priv->last_known_state) ==
+								should_be_on) {
+			/* All is good, cancel pending retry if there is one */
+			ril_radio_cancel_retry(self);
+		} else if (priv->state_changed_while_request_pending) {
+			/* Hmm... RIL's reaction was inadequate, repeat */
+			ril_radio_submit_power_request(self, should_be_on);
+		} else if (!priv->retry_id) {
+			/* There has been no reaction so far, wait a bit */
+			DBG("%sretry scheduled", priv->log_prefix);
+			priv->retry_id = g_timeout_add_seconds(POWER_RETRY_SECS,
+					ril_radio_power_request_retry_cb, self);
+		}
+	}
+
+	/* Don't update public state while something is pending */
+	if (!priv->pending_id && !priv->retry_id &&
+				self->state != priv->last_known_state) {
+		DBG("%s%s -> %s", priv->log_prefix,
+			ril_radio_state_to_string(self->state),
+			ril_radio_state_to_string(priv->last_known_state));
+		self->state = priv->last_known_state;
+		g_signal_emit(self, ril_radio_signals[SIGNAL_STATE_CHANGED], 0);
+	}
+}
+
+static void ril_radio_power_request_cb(GRilIoChannel *channel, int ril_status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_radio *self = user_data;
+	struct ril_radio_priv *priv = self->priv;
+
+	GASSERT(priv->pending_id);
+	priv->pending_id = 0;
+
+	if (ril_status != RIL_E_SUCCESS) {
+		ofono_error("Power request failed: %s",
+					ril_error_to_string(ril_status));
+	}
+
+	if (priv->next_state_valid) {
+		ril_radio_submit_power_request(self, priv->next_state);
+	} else {
+		ril_radio_check_state(self);
+	}
+}
+
+static void ril_radio_submit_power_request(struct ril_radio *self, gboolean on)
+{
+	struct ril_radio_priv *priv = self->priv;
+	GRilIoRequest *req = grilio_request_sized_new(8);
+
+	grilio_request_append_int32(req, 1);
+	grilio_request_append_int32(req, on); /* Radio ON=1, OFF=0 */
+
+	priv->next_state_valid = FALSE;
+	priv->next_state = on;
+	priv->state_changed_while_request_pending = 0;
+	ril_radio_cancel_retry(self);
+
+	GASSERT(!priv->pending_id);
+	priv->pending_id = grilio_queue_send_request_full(priv->q, req,
+		RIL_REQUEST_RADIO_POWER, ril_radio_power_request_cb, NULL, self);
+	grilio_request_unref(req);
+}
+
+static void ril_radio_power_request(struct ril_radio *self, gboolean on,
+							gboolean allow_repeat)
+{
+	struct ril_radio_priv *priv = self->priv;
+	const char *on_off = on ? "on" : "off";
+
+	if (priv->pending_id) {
+		if (allow_repeat || priv->next_state != on) {
+			/* Wait for the pending request to complete */
+			priv->next_state_valid = TRUE;
+			priv->next_state = on;
+			DBG("%s%s (queued)", priv->log_prefix, on_off);
+		} else {
+			DBG("%s%s (ignored)", priv->log_prefix, on_off);
+		}
+	} else {
+		DBG("%s%s", priv->log_prefix, on_off);
+		ril_radio_submit_power_request(self, on);
+	}
+}
+
+void ril_radio_confirm_power_on(struct ril_radio *self)
+{
+	if (G_LIKELY(self) && ril_radio_power_should_be_on(self)) {
+		ril_radio_power_request(self, TRUE, TRUE);
+	}
+}
+
+void ril_radio_power_cycle(struct ril_radio *self)
+{
+	if (G_LIKELY(self)) {
+		struct ril_radio_priv *priv = self->priv;
+
+		if (ril_radio_state_off(priv->last_known_state)) {
+			DBG("%spower is already off", priv->log_prefix);
+			GASSERT(!priv->power_cycle);
+		} else if (priv->power_cycle) {
+			DBG("%salready in progress", priv->log_prefix);
+		} else {
+			DBG("%sinitiated", priv->log_prefix);
+			priv->power_cycle = TRUE;
+			if (!priv->pending_id) {
+				ril_radio_submit_power_request(self, FALSE);
+			}
+		}
+	}
+}
+
+void ril_radio_power_on(struct ril_radio *self, gpointer tag)
+{
+	if (G_LIKELY(self)) {
+		struct ril_radio_priv *priv = self->priv;
+		const gboolean was_on = ril_radio_power_should_be_on(self);
+
+		DBG("%s%p", priv->log_prefix, tag);
+		g_hash_table_insert(priv->req_table, tag, tag);
+		if (!was_on) {
+			ril_radio_power_request(self, TRUE, FALSE);
+		}
+	}
+}
+
+void ril_radio_power_off(struct ril_radio *self, gpointer tag)
+{
+	if (G_LIKELY(self)) {
+		struct ril_radio_priv *priv = self->priv;
+
+		DBG("%s%p", priv->log_prefix, tag);
+		if (g_hash_table_remove(priv->req_table, tag) &&
+				!ril_radio_power_should_be_on(self)) {
+			/* The last one turns the lights off */
+			ril_radio_power_request(self, FALSE, FALSE);
+		}
+	}
+}
+
+gulong ril_radio_add_state_changed_handler(struct ril_radio *self,
+					ril_radio_cb_t cb, void *arg)
+{
+	return (G_LIKELY(self) && G_LIKELY(cb)) ? g_signal_connect(self,
+		SIGNAL_STATE_CHANGED_NAME, G_CALLBACK(cb), arg) : 0;
+}
+
+void ril_radio_remove_handler(struct ril_radio *self, gulong id)
+{
+	if (G_LIKELY(self) && G_LIKELY(id)) {
+		g_signal_handler_disconnect(self, id);
+	}
+}
+
+enum ril_radio_state ril_radio_state_parse(const void *data, guint len)
+{
+	GRilIoParser rilp;
+	int radio_state;
+
+	grilio_parser_init(&rilp, data, len);
+	if (grilio_parser_get_int32(&rilp, &radio_state)) {
+		return radio_state;
+	} else {
+		ofono_error("Error parsing radio state");
+		return RADIO_STATE_UNAVAILABLE;
+	}
+}
+
+static void ril_radio_state_changed(GRilIoChannel *io, guint code,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_radio *self = user_data;
+	enum ril_radio_state radio_state = ril_radio_state_parse(data, len);
+
+	GASSERT(code == RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED);
+	if (radio_state != RADIO_STATE_UNAVAILABLE) {
+		struct ril_radio_priv *priv = self->priv;
+
+		DBG("%s%s", priv->log_prefix,
+			ril_radio_state_to_string(radio_state));
+		GASSERT(!priv->pending_id || !priv->retry_id);
+
+		if (priv->power_cycle && ril_radio_state_off(radio_state)) {
+			DBG("%sswitched off for power cycle", priv->log_prefix);
+			priv->power_cycle = FALSE;
+		}
+
+		if (priv->pending_id) {
+			priv->state_changed_while_request_pending++;
+		}
+
+		priv->last_known_state = radio_state;
+		ril_radio_check_state(self);
+	}
+}
+
+struct ril_radio *ril_radio_new(GRilIoChannel *io)
+{
+	struct ril_radio *self = g_object_new(RIL_RADIO_TYPE, NULL);
+	struct ril_radio_priv *priv = self->priv;
+
+	priv->io = grilio_channel_ref(io);
+	priv->q = grilio_queue_new(priv->io);
+	priv->log_prefix =
+		(io && io->name && io->name[0] && strcmp(io->name, "RIL")) ?
+		g_strconcat(io->name, " ", NULL) : g_strdup("");
+	DBG("%s", priv->log_prefix);
+	priv->state_event_id = grilio_channel_add_unsol_event_handler(priv->io,
+				ril_radio_state_changed,
+				RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, self);
+	return self;
+}
+
+struct ril_radio *ril_radio_ref(struct ril_radio *self)
+{
+	if (G_LIKELY(self)) {
+		g_object_ref(RIL_RADIO(self));
+		return self;
+	} else {
+		return NULL;
+	}
+}
+
+void ril_radio_unref(struct ril_radio *self)
+{
+	if (G_LIKELY(self)) {
+		g_object_unref(RIL_RADIO(self));
+	}
+}
+
+static void ril_radio_init(struct ril_radio *self)
+{
+	struct ril_radio_priv *priv = G_TYPE_INSTANCE_GET_PRIVATE(self,
+					RIL_RADIO_TYPE, struct ril_radio_priv);
+	self->priv = priv;
+	priv->req_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+								NULL, NULL);
+}
+
+static void ril_radio_dispose(GObject *object)
+{
+	struct ril_radio *self = RIL_RADIO(object);
+	struct ril_radio_priv *priv = self->priv;
+
+	if (priv->state_event_id) {
+		grilio_channel_remove_handler(priv->io, priv->state_event_id);
+		priv->state_event_id = 0;
+	}
+	if (priv->pending_id) {
+		grilio_queue_cancel_request(priv->q, priv->pending_id, FALSE);
+		priv->pending_id = 0;
+	}
+	priv->next_state_valid = FALSE;
+	ril_radio_cancel_retry(self);
+	grilio_queue_cancel_all(priv->q, FALSE);
+	G_OBJECT_CLASS(ril_radio_parent_class)->dispose(object);
+}
+
+static void ril_radio_finalize(GObject *object)
+{
+	struct ril_radio *self = RIL_RADIO(object);
+	struct ril_radio_priv *priv = self->priv;
+
+	DBG("%s", priv->log_prefix);
+	g_free(priv->log_prefix);
+	grilio_channel_unref(priv->io);
+	grilio_queue_unref(priv->q);
+	g_hash_table_unref(priv->req_table);
+	G_OBJECT_CLASS(ril_radio_parent_class)->finalize(object);
+}
+
+static void ril_radio_class_init(RilRadioClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS(klass);
+
+	object_class->dispose = ril_radio_dispose;
+	object_class->finalize = ril_radio_finalize;
+	g_type_class_add_private(klass, sizeof(struct ril_radio_priv));
+	ril_radio_signals[SIGNAL_STATE_CHANGED] =
+		g_signal_new(SIGNAL_STATE_CHANGED_NAME,
+			G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
+			0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+}
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_radio.h

@@ -0,0 +1,50 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#ifndef RIL_RADIO_H
+#define RIL_RADIO_H
+
+#include "ril_types.h"
+
+struct ril_radio {
+	GObject object;
+	struct ril_radio_priv *priv;
+	enum ril_radio_state state;
+};
+
+typedef void (*ril_radio_cb_t)(struct ril_radio *radio, void *arg);
+
+struct ril_radio *ril_radio_new(GRilIoChannel *io);
+struct ril_radio *ril_radio_ref(struct ril_radio *radio);
+void ril_radio_unref(struct ril_radio *radio);
+
+void ril_radio_power_on(struct ril_radio *radio, gpointer tag);
+void ril_radio_power_off(struct ril_radio *radio, gpointer tag);
+void ril_radio_confirm_power_on(struct ril_radio *radio);
+void ril_radio_power_cycle(struct ril_radio *radio);
+gulong ril_radio_add_state_changed_handler(struct ril_radio *radio,
+					ril_radio_cb_t cb, void *arg);
+void ril_radio_remove_handler(struct ril_radio *radio, gulong id);
+enum ril_radio_state ril_radio_state_parse(const void *data, guint len);
+
+#endif /* RIL_RADIO */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_radio_settings.c

@@ -0,0 +1,316 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_util.h"
+#include "ril_log.h"
+#include "ril_constants.h"
+
+struct ril_radio_settings {
+	GRilIoQueue *q;
+	struct ofono_radio_settings *rs;
+	enum ofono_radio_access_mode access_mode;
+	gboolean enable_4g;
+	int ratmode;
+	guint query_rats_id;
+};
+
+struct ril_radio_settings_cbd {
+	struct ril_radio_settings *rsd;
+	union _ofono_radio_settings_cb {
+		ofono_radio_settings_rat_mode_set_cb_t rat_mode_set;
+		ofono_radio_settings_rat_mode_query_cb_t rat_mode_query;
+		ofono_radio_settings_available_rats_query_cb_t available_rats;
+		gpointer ptr;
+	} cb;
+	gpointer data;
+};
+
+#define ril_radio_settings_cbd_free g_free
+
+static inline struct ril_radio_settings *ril_radio_settings_get_data(
+					struct ofono_radio_settings *rs)
+{
+	return ofono_radio_settings_get_data(rs);
+}
+
+static struct ril_radio_settings_cbd *ril_radio_settings_cbd_new(
+			struct ril_radio_settings *rsd, void *cb, void *data)
+{
+	struct ril_radio_settings_cbd *cbd;
+
+	cbd = g_new0(struct ril_radio_settings_cbd, 1);
+	cbd->rsd = rsd;
+	cbd->cb.ptr = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+static enum ofono_radio_access_mode ril_radio_settings_pref_to_mode(int pref)
+{
+	switch (pref) {
+	case PREF_NET_TYPE_LTE_CDMA_EVDO:
+	case PREF_NET_TYPE_LTE_GSM_WCDMA:
+	case PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA:
+	case PREF_NET_TYPE_LTE_ONLY:
+	case PREF_NET_TYPE_LTE_WCDMA:
+		return OFONO_RADIO_ACCESS_MODE_LTE;
+	case PREF_NET_TYPE_GSM_ONLY:
+		return OFONO_RADIO_ACCESS_MODE_GSM;
+	case PREF_NET_TYPE_GSM_WCDMA_AUTO:
+	case PREF_NET_TYPE_WCDMA:
+	case PREF_NET_TYPE_GSM_WCDMA:
+		return OFONO_RADIO_ACCESS_MODE_UMTS;
+	default:
+		return OFONO_RADIO_ACCESS_MODE_ANY;
+	}
+}
+
+static int ril_radio_settings_mode_to_pref(struct ril_radio_settings *rsd,
+					enum ofono_radio_access_mode mode)
+{
+	switch (mode) {
+	case OFONO_RADIO_ACCESS_MODE_ANY:
+	case OFONO_RADIO_ACCESS_MODE_LTE:
+		if (rsd->enable_4g) {
+			return PREF_NET_TYPE_LTE_WCDMA;
+		}
+		/* no break */
+	case OFONO_RADIO_ACCESS_MODE_UMTS:
+		return PREF_NET_TYPE_GSM_WCDMA_AUTO;
+	case OFONO_RADIO_ACCESS_MODE_GSM:
+		return PREF_NET_TYPE_GSM_ONLY;
+	default:
+		return -1;
+	}
+}
+
+static void ril_radio_settings_submit_request(struct ril_radio_settings *rsd,
+	GRilIoRequest* req, guint code, GRilIoChannelResponseFunc response,
+							void *cb, void *data)
+{
+	grilio_queue_send_request_full(rsd->q, req, code, response,
+				ril_radio_settings_cbd_free,
+				ril_radio_settings_cbd_new(rsd, cb, data));
+}
+
+static void ril_radio_settings_set_rat_mode_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_radio_settings_cbd *cbd = user_data;
+	ofono_radio_settings_rat_mode_set_cb_t cb = cbd->cb.rat_mode_set;
+
+	if (status == RIL_E_SUCCESS) {
+		cb(ril_error_ok(&error), cbd->data);
+	} else {
+		ofono_error("failed to set rat mode");
+		cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static GRilIoRequest *ril_radio_settings_set_pref_req(int pref)
+{
+	GRilIoRequest *req = grilio_request_sized_new(8);
+	grilio_request_append_int32(req, 1);        /* Number of params */
+	grilio_request_append_int32(req, pref);
+	return req;
+}
+
+static int ril_radio_settings_parse_pref_resp(const void *data, guint len)
+{
+	GRilIoParser rilp;
+	int pref = -1;
+
+	grilio_parser_init(&rilp, data, len);
+	grilio_parser_get_int32(&rilp, NULL);
+	grilio_parser_get_int32(&rilp, &pref);
+	return pref;
+}
+
+static void ril_radio_settings_set_rat_mode(struct ofono_radio_settings *rs,
+		enum ofono_radio_access_mode mode,
+		ofono_radio_settings_rat_mode_set_cb_t cb, void *data)
+{
+	struct ril_radio_settings *rsd = ril_radio_settings_get_data(rs);
+	int pref = ril_radio_settings_mode_to_pref(rsd, mode);
+	GRilIoRequest *req;
+
+	if (pref < 0) pref = rsd->ratmode;
+	DBG("rat mode set %d (ril %d)", mode, pref);
+	req = ril_radio_settings_set_pref_req(pref);
+	ril_radio_settings_submit_request(rsd, req,
+			RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE,
+			ril_radio_settings_set_rat_mode_cb, cb, data);
+	grilio_request_unref(req);
+}
+
+static void ril_radio_settings_query_rat_mode_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_radio_settings_cbd *cbd = user_data;
+	struct ril_radio_settings *rsd = cbd->rsd;
+	ofono_radio_settings_rat_mode_query_cb_t cb = cbd->cb.rat_mode_query;
+
+	if (status == RIL_E_SUCCESS) {
+		rsd->ratmode = ril_radio_settings_parse_pref_resp(data, len);
+		DBG("rat mode %d (ril %d)",
+			ril_radio_settings_pref_to_mode(rsd->ratmode),
+			rsd->ratmode);
+	} else {
+		/*
+		 * With certain versions of RIL, preferred network type
+		 * queries don't work even though setting preferred network
+		 * type does actually work. In this case, assume that our
+		 * cached network type is the right one.
+		 */
+		ofono_error("rat mode query failed, assuming %d (ril %d)",
+			ril_radio_settings_pref_to_mode(rsd->ratmode),
+			rsd->ratmode);
+	}
+
+	cb(ril_error_ok(&error), ril_radio_settings_pref_to_mode(rsd->ratmode),
+								cbd->data);
+}
+
+static void ril_radio_settings_query_rat_mode(struct ofono_radio_settings *rs,
+		ofono_radio_settings_rat_mode_query_cb_t cb, void *data)
+{
+	struct ril_radio_settings *rsd = ril_radio_settings_get_data(rs);
+
+	DBG("rat mode query");
+	ril_radio_settings_submit_request(rsd, NULL,
+			RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE,
+			ril_radio_settings_query_rat_mode_cb, cb, data);
+}
+
+static gboolean ril_radio_settings_query_available_rats_cb(gpointer data)
+{
+	struct ofono_error error;
+	struct ril_radio_settings_cbd *cbd = data;
+	guint rats = OFONO_RADIO_ACCESS_MODE_GSM | OFONO_RADIO_ACCESS_MODE_UMTS;
+
+	if (cbd->rsd->enable_4g) {
+		rats |= OFONO_RADIO_ACCESS_MODE_LTE;
+	}
+
+	GASSERT(cbd->rsd->query_rats_id);
+	cbd->rsd->query_rats_id = 0;
+	cbd->cb.available_rats(ril_error_ok(&error), rats, cbd->data);
+	return FALSE;
+}
+
+static void ril_radio_settings_query_available_rats(
+		struct ofono_radio_settings *rs,
+		ofono_radio_settings_available_rats_query_cb_t cb, void *data)
+{
+	struct ril_radio_settings *rsd = ril_radio_settings_get_data(rs);
+
+	DBG("");
+	GASSERT(!rsd->query_rats_id);
+	rsd->query_rats_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
+				ril_radio_settings_query_available_rats_cb,
+				ril_radio_settings_cbd_new(rsd, cb, data),
+				ril_radio_settings_cbd_free);
+}
+
+static void ril_radio_settings_init_query_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	int pref;
+	struct ril_radio_settings *rsd = user_data;
+	enum ofono_radio_access_mode mode;
+
+	if (status == RIL_E_SUCCESS) {
+		pref = ril_radio_settings_parse_pref_resp(data, len);
+		DBG("rat mode %d", pref);
+	} else {
+		ofono_error("initial rat mode query failed");
+		pref = ril_radio_settings_mode_to_pref(rsd,
+						OFONO_RADIO_ACCESS_MODE_ANY);
+	}
+
+	mode = ril_radio_settings_pref_to_mode(pref);
+
+	if (!rsd->enable_4g && mode == OFONO_RADIO_ACCESS_MODE_LTE) {
+		rsd->ratmode = ril_radio_settings_mode_to_pref(rsd,
+						OFONO_RADIO_ACCESS_MODE_UMTS);
+	} else {
+		rsd->ratmode = pref;
+	}
+
+	if (rsd->ratmode != pref || status != RIL_E_SUCCESS) {
+		GRilIoRequest *req;
+
+		DBG("forcing rat mode %d", rsd->ratmode);
+		req = ril_radio_settings_set_pref_req(rsd->ratmode);
+		grilio_queue_send_request(rsd->q, req,
+				RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE);
+		grilio_request_unref(req);
+	}
+
+	ofono_radio_settings_register(rsd->rs);
+}
+
+static int ril_radio_settings_probe(struct ofono_radio_settings *rs,
+					unsigned int vendor, void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_radio_settings *rsd = g_new0(struct ril_radio_settings, 1);
+
+	DBG("");
+	rsd->rs = rs;
+	rsd->q = grilio_queue_new(ril_modem_io(modem));
+	rsd->enable_4g = ril_modem_4g_enabled(modem);
+	grilio_queue_send_request_full(rsd->q, NULL,
+				RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE,
+				ril_radio_settings_init_query_cb, NULL, rsd);
+
+	ofono_radio_settings_set_data(rs, rsd);
+	return 0;
+}
+
+static void ril_radio_settings_remove(struct ofono_radio_settings *rs)
+{
+	struct ril_radio_settings *rsd = ril_radio_settings_get_data(rs);
+
+	DBG("");
+	ofono_radio_settings_set_data(rs, NULL);
+	if (rsd->query_rats_id > 0) {
+		g_source_remove(rsd->query_rats_id);
+        }
+
+	grilio_queue_cancel_all(rsd->q, FALSE);
+	grilio_queue_unref(rsd->q);
+	g_free(rsd);
+}
+
+const struct ofono_radio_settings_driver ril_radio_settings_driver = {
+	.name                 = RILMODEM_DRIVER,
+	.probe                = ril_radio_settings_probe,
+	.remove               = ril_radio_settings_remove,
+	.query_rat_mode       = ril_radio_settings_query_rat_mode,
+	.set_rat_mode         = ril_radio_settings_set_rat_mode,
+	.query_available_rats = ril_radio_settings_query_available_rats
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_sim_card.c

@@ -0,0 +1,532 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_sim_card.h"
+#include "ril_radio.h"
+#include "ril_util.h"
+#include "ril_log.h"
+
+#include <grilio_queue.h>
+#include <grilio_request.h>
+#include <grilio_parser.h>
+
+typedef GObjectClass RilSimCardClass;
+typedef struct ril_sim_card RilSimCard;
+
+enum ril_sim_card_event {
+	EVENT_SIM_STATUS_CHANGED,
+	EVENT_UICC_SUBSCRIPTION_STATUS_CHANGED,
+	EVENT_COUNT
+};
+
+struct ril_sim_card_priv {
+	GRilIoChannel *io;
+	GRilIoQueue *q;
+	int flags;
+	guint status_req_id;
+	gulong event_id[EVENT_COUNT];
+};
+
+enum ril_sim_card_signal {
+	SIGNAL_STATUS_RECEIVED,
+	SIGNAL_STATUS_CHANGED,
+	SIGNAL_STATE_CHANGED,
+	SIGNAL_APP_CHANGED,
+	SIGNAL_COUNT
+};
+
+#define SIGNAL_STATUS_RECEIVED_NAME     "ril-simcard-status-received"
+#define SIGNAL_STATUS_CHANGED_NAME      "ril-simcard-status-changed"
+#define SIGNAL_STATE_CHANGED_NAME       "ril-simcard-state-changed"
+#define SIGNAL_APP_CHANGED_NAME         "ril-simcard-app-changed"
+
+static guint ril_sim_card_signals[SIGNAL_COUNT] = { 0 };
+
+G_DEFINE_TYPE(RilSimCard, ril_sim_card, G_TYPE_OBJECT)
+#define RIL_SIMCARD_TYPE (ril_sim_card_get_type())
+#define RIL_SIMCARD(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+	RIL_SIMCARD_TYPE, RilSimCard))
+
+#define RIL_SIMCARD_STATE_CHANGED  (0x01)
+#define RIL_SIMCARD_STATUS_CHANGED (0x02)
+
+static void ril_sim_card_request_status(struct ril_sim_card *self);
+
+static gboolean ril_sim_card_app_equal(const struct ril_sim_card_app *a1,
+					const struct ril_sim_card_app *a2)
+{
+	if (a1 == a2) {
+		return TRUE;
+	} else if (!a1 || !a2) {
+		return FALSE;
+	} else {
+		return a1->app_type == a2->app_type &&
+			a1->app_state == a2->app_state &&
+			a1->perso_substate == a2->perso_substate &&
+			a1->pin_replaced == a2->pin_replaced &&
+			a1->pin1_state == a2->pin1_state &&
+			a1->pin2_state == a2->pin2_state &&
+			!g_strcmp0(a1->aid, a2->aid) &&
+			!g_strcmp0(a1->label, a2->label);
+	}
+}
+
+static int ril_sim_card_status_compare(const struct ril_sim_card_status *s1,
+					const struct ril_sim_card_status *s2)
+{
+	if (s1 == s2) {
+		return 0;
+	} else if (!s1 || !s2) {
+		return RIL_SIMCARD_STATE_CHANGED | RIL_SIMCARD_STATUS_CHANGED;
+	} else {
+		int diff = 0;
+
+		if (s1->card_state != s2->card_state) {
+			diff |= RIL_SIMCARD_STATE_CHANGED;
+		}
+
+		if (s1->pin_state != s2->pin_state ||
+			s1->gsm_umts_index != s2->gsm_umts_index ||
+			s1->cdma_index != s2->cdma_index ||
+			s1->ims_index != s2->ims_index ||
+			s1->num_apps != s2->num_apps) {
+			diff |= RIL_SIMCARD_STATUS_CHANGED;
+		} else {
+			int i;
+
+			for (i = 0; i < s1->num_apps; i++) {
+				if (!ril_sim_card_app_equal(s1->apps + i,
+							     s2->apps + i)) {
+					diff |= RIL_SIMCARD_STATUS_CHANGED;
+					break;
+				}
+			}
+		}
+
+		return diff;
+	}
+}
+
+static void ril_sim_card_status_free(struct ril_sim_card_status *status)
+{
+	if (status) {
+		if (status->apps) {
+			int i;
+
+			for (i = 0; i < status->num_apps; i++) {
+				g_free(status->apps[i].aid);
+				g_free(status->apps[i].label);
+			}
+			g_free(status->apps);
+		}
+		g_free(status);
+	}
+}
+
+static void ril_sim_card_subscribe(struct ril_sim_card *self,
+						int app_index, int sub_status)
+{
+	struct ril_sim_card_priv *priv = self->priv;
+	GRilIoRequest *req = grilio_request_sized_new(16);
+	const guint sub_id = self->slot;
+
+	DBG("%u,%d,%u,%d", self->slot, app_index, sub_id, sub_status);
+	grilio_request_append_int32(req, self->slot);
+	grilio_request_append_int32(req, app_index);
+	grilio_request_append_int32(req, sub_id);
+	grilio_request_append_int32(req, sub_status);
+	grilio_queue_send_request(priv->q, req, (priv->io->ril_version <= 9 &&
+		(priv->flags & RIL_SIM_CARD_V9_UICC_SUBSCRIPTION_WORKAROUND)) ?
+				RIL_REQUEST_V9_SET_UICC_SUBSCRIPTION :
+				RIL_REQUEST_SET_UICC_SUBSCRIPTION);
+	grilio_request_unref(req);
+}
+
+static int ril_sim_card_select_app(const struct ril_sim_card_status *status)
+{
+	int selected_app = -1;
+	guint i;
+
+	for (i = 0; i < status->num_apps; i++) {
+		const int type = status->apps[i].app_type;
+		if (type == RIL_APPTYPE_USIM || type == RIL_APPTYPE_RUIM) {
+			selected_app = i;
+			break;
+		} else if (type != RIL_APPTYPE_UNKNOWN && selected_app == -1) {
+			selected_app = i;
+		}
+	}
+
+	DBG("%d", selected_app);
+	return selected_app;
+}
+
+static void ril_sim_card_update_app(struct ril_sim_card *self)
+{
+	const struct ril_sim_card_app *old_app = self->app;
+	const struct ril_sim_card_status *status = self->status;
+	int app_index;
+
+	if (status->card_state == RIL_CARDSTATE_PRESENT) {
+		if (status->gsm_umts_index >= 0 &&
+				status->gsm_umts_index < status->num_apps) {
+			app_index = status->gsm_umts_index;
+		} else {
+			app_index = ril_sim_card_select_app(status);
+			if (app_index >= 0) {
+				ril_sim_card_subscribe(self, app_index, 1);
+			}
+		}
+	} else {
+		app_index = -1;
+	}
+
+	if (app_index >= 0 &&
+		status->apps[app_index].app_type != RIL_APPTYPE_UNKNOWN) {
+		self->app = status->apps + app_index;
+	} else {
+		self->app = NULL;
+	}
+
+	if (!ril_sim_card_app_equal(old_app, self->app)) {
+		g_signal_emit(self,
+			ril_sim_card_signals[SIGNAL_APP_CHANGED], 0);
+	}
+}
+
+static void ril_sim_card_update_status(struct ril_sim_card *self,
+					struct ril_sim_card_status *status)
+{
+	const int diff = ril_sim_card_status_compare(self->status, status);
+
+	if (diff) {
+		struct ril_sim_card_status *old_status = self->status;
+
+		self->status = status;
+		ril_sim_card_update_app(self);
+		g_signal_emit(self, ril_sim_card_signals[
+						SIGNAL_STATUS_RECEIVED], 0);
+		if (diff & RIL_SIMCARD_STATUS_CHANGED) {
+			DBG("status changed");
+			g_signal_emit(self, ril_sim_card_signals[
+						SIGNAL_STATUS_CHANGED], 0);
+		}
+		if (diff & RIL_SIMCARD_STATE_CHANGED) {
+			DBG("state changed");
+			g_signal_emit(self, ril_sim_card_signals[
+						SIGNAL_STATE_CHANGED], 0);
+		}
+		ril_sim_card_status_free(old_status);
+	} else {
+		ril_sim_card_status_free(status);
+		g_signal_emit(self, ril_sim_card_signals[
+						SIGNAL_STATUS_RECEIVED], 0);
+	}
+}
+
+static gboolean ril_sim_card_app_parse(GRilIoParser *rilp,
+						struct ril_sim_card_app *app)
+{
+	gint32 app_type, app_state, perso_substate;
+	gint32 pin_replaced, pin1_state, pin2_state;
+
+	grilio_parser_get_int32(rilp, &app_type);
+	grilio_parser_get_int32(rilp, &app_state);
+
+	/*
+	 * Consider RIL_APPSTATE_ILLEGAL also READY. Even if app state is
+	 * RIL_APPSTATE_ILLEGAL (-1), ICC operations must be permitted.
+	 * Network access requests will anyway be rejected and ME will be
+	 * in limited service.
+	 */
+	if (app_state == RIL_APPSTATE_ILLEGAL) {
+		DBG("RIL_APPSTATE_ILLEGAL => RIL_APPSTATE_READY");
+		app_state = RIL_APPSTATE_READY;
+	}
+
+	grilio_parser_get_int32(rilp, &perso_substate);
+	app->aid = grilio_parser_get_utf8(rilp);
+	app->label = grilio_parser_get_utf8(rilp);
+
+	if (grilio_parser_get_int32(rilp, &pin_replaced) &&
+		grilio_parser_get_int32(rilp, &pin1_state) &&
+		grilio_parser_get_int32(rilp, &pin2_state)) {
+
+		app->app_type = app_type;
+		app->app_state = app_state;
+		app->perso_substate = perso_substate;
+		app->pin_replaced = pin_replaced;
+		app->pin1_state = pin1_state;
+		app->pin2_state = pin2_state;
+
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+static struct ril_sim_card_status *ril_sim_card_status_parse(const void *data,
+								guint len)
+{
+	GRilIoParser rilp;
+	gint32 card_state, pin_state, gsm_umts_index, cdma_index;
+        gint32 ims_index, num_apps;
+
+	grilio_parser_init(&rilp, data, len);
+
+	if (!grilio_parser_get_int32(&rilp, &card_state) ||
+		!grilio_parser_get_int32(&rilp, &pin_state) ||
+		!grilio_parser_get_int32(&rilp, &gsm_umts_index) ||
+		!grilio_parser_get_int32(&rilp, &cdma_index) ||
+		!grilio_parser_get_int32(&rilp, &ims_index) ||
+		!grilio_parser_get_int32(&rilp, &num_apps)) {
+		ofono_error("Failed to parse SIM card status request");
+		return NULL;
+	} else if (num_apps < 0 || num_apps > RIL_CARD_MAX_APPS) {
+		ofono_error("Invalid SIM app count %d", num_apps);
+		return NULL;
+	} else {
+		int i;
+		struct ril_sim_card_status *status =
+			g_new0(struct ril_sim_card_status, 1);
+
+		DBG("card_state=%d, universal_pin_state=%d, gsm_umts_index=%d, "
+			"cdma_index=%d, ims_index=%d, num_apps=%d",
+			card_state, pin_state, gsm_umts_index, cdma_index,
+			ims_index, num_apps);
+
+		status->card_state = card_state;
+		status->pin_state = pin_state;
+		status->gsm_umts_index = gsm_umts_index;
+		status->cdma_index = cdma_index;
+		status->ims_index = ims_index;
+		status->num_apps = num_apps;
+
+		if (num_apps > 0) {
+			status->apps = g_new0(struct ril_sim_card_app, num_apps);
+		}
+
+		for (i = 0; i < num_apps; i++) {
+			struct ril_sim_card_app *app = status->apps + i;
+
+			if (ril_sim_card_app_parse(&rilp, app)) {
+				DBG("app[%d]: type=%d, state=%d, "
+					"perso_substate=%d, aid_ptr=%s, "
+					"label=%s, pin1_replaced=%d, pin1=%d, "
+					"pin2=%d", i, app->app_type,
+					app->app_state, app->perso_substate,
+					app->aid, app->label,
+					app->pin_replaced, app->pin1_state,
+					app->pin2_state);
+			} else {
+				break;
+			}
+		}
+
+		if (i == num_apps) {
+			return status;
+		} else {
+			ril_sim_card_status_free(status);
+			return NULL;
+		}
+	}
+}
+
+static void ril_sim_card_status_cb(GRilIoChannel *io, int ril_status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_sim_card *self = user_data;
+	struct ril_sim_card_priv *priv = self->priv;
+
+	GASSERT(priv->status_req_id);
+	priv->status_req_id = 0;
+
+	if (ril_status == RIL_E_SUCCESS) {
+		struct ril_sim_card_status *status =
+			ril_sim_card_status_parse(data, len);
+
+		if (status) {
+			ril_sim_card_update_status(self, status);
+		}
+	}
+}
+
+static void ril_sim_card_request_status(struct ril_sim_card *self)
+{
+	struct ril_sim_card_priv *priv = self->priv;
+
+	if (priv->status_req_id) {
+		/* Retry right away, don't wait for retry timeout to expire */
+		grilio_channel_retry_request(priv->io, priv->status_req_id);
+	} else {
+		GRilIoRequest* req = grilio_request_new();
+
+		grilio_request_set_retry(req, RIL_RETRY_SECS*1000, -1);
+		priv->status_req_id = grilio_queue_send_request_full(priv->q,
+					req, RIL_REQUEST_GET_SIM_STATUS,
+					ril_sim_card_status_cb, NULL, self);
+		grilio_request_unref(req);
+	}
+}
+
+static void ril_sim_card_status_changed(GRilIoChannel *io, guint code,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_sim_card *self = user_data;
+
+	ril_sim_card_request_status(self);
+}
+
+struct ril_sim_card *ril_sim_card_new(GRilIoChannel *io, guint slot, int flags)
+{
+	struct ril_sim_card *self = g_object_new(RIL_SIMCARD_TYPE, NULL);
+	struct ril_sim_card_priv *priv = self->priv;
+
+	/*
+	 * We need to know the RIL version (for UICC subscription hack),
+	 * so we must be connected. The caller is supposed to make sure
+	 * that we get connected first.
+	 */
+	DBG("%u", slot);
+	GASSERT(io->connected);
+
+	self->slot = slot;
+	priv->io = grilio_channel_ref(io);
+	priv->q = grilio_queue_new(io);
+	priv->flags = flags;
+
+	priv->event_id[EVENT_SIM_STATUS_CHANGED] =
+		grilio_channel_add_unsol_event_handler(priv->io,
+			ril_sim_card_status_changed,
+			RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, self);
+	priv->event_id[EVENT_UICC_SUBSCRIPTION_STATUS_CHANGED] =
+		grilio_channel_add_unsol_event_handler(priv->io,
+			ril_sim_card_status_changed,
+			RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED, self);
+	ril_sim_card_request_status(self);
+	return self;
+}
+
+struct ril_sim_card *ril_sim_card_ref(struct ril_sim_card *self)
+{
+	if (G_LIKELY(self)) {
+		g_object_ref(RIL_SIMCARD(self));
+		return self;
+	} else {
+		return NULL;
+	}
+}
+
+void ril_sim_card_unref(struct ril_sim_card *self)
+{
+	if (G_LIKELY(self)) {
+		g_object_unref(RIL_SIMCARD(self));
+	}
+}
+
+gulong ril_sim_card_add_status_received_handler(struct ril_sim_card *self,
+					ril_sim_card_cb_t cb, void *arg)
+{
+	return (G_LIKELY(self) && G_LIKELY(cb)) ? g_signal_connect(self,
+		SIGNAL_STATUS_RECEIVED_NAME, G_CALLBACK(cb), arg) : 0;
+}
+
+gulong ril_sim_card_add_status_changed_handler(struct ril_sim_card *self,
+					ril_sim_card_cb_t cb, void *arg)
+{
+	return (G_LIKELY(self) && G_LIKELY(cb)) ? g_signal_connect(self,
+		SIGNAL_STATUS_CHANGED_NAME, G_CALLBACK(cb), arg) : 0;
+}
+
+gulong ril_sim_card_add_state_changed_handler(struct ril_sim_card *self,
+					ril_sim_card_cb_t cb, void *arg)
+{
+	return (G_LIKELY(self) && G_LIKELY(cb)) ? g_signal_connect(self,
+		SIGNAL_STATE_CHANGED_NAME, G_CALLBACK(cb), arg) : 0;
+}
+
+gulong ril_sim_card_add_app_changed_handler(struct ril_sim_card *self,
+					ril_sim_card_cb_t cb, void *arg)
+{
+	return (G_LIKELY(self) && G_LIKELY(cb)) ? g_signal_connect(self,
+		SIGNAL_APP_CHANGED_NAME, G_CALLBACK(cb), arg) : 0;
+}
+
+void ril_sim_card_remove_handler(struct ril_sim_card *self, gulong id)
+{
+	if (G_LIKELY(self) && G_LIKELY(id)) {
+		g_signal_handler_disconnect(self, id);
+	}
+}
+
+static void ril_sim_card_init(struct ril_sim_card *self)
+{
+	self->priv = G_TYPE_INSTANCE_GET_PRIVATE(self, RIL_SIMCARD_TYPE,
+						struct ril_sim_card_priv);
+}
+
+static void ril_sim_card_dispose(GObject *object)
+{
+	struct ril_sim_card *self = RIL_SIMCARD(object);
+	struct ril_sim_card_priv *priv = self->priv;
+
+	grilio_channel_remove_handlers(priv->io, priv->event_id, EVENT_COUNT);
+	grilio_queue_cancel_all(priv->q, TRUE);
+	G_OBJECT_CLASS(ril_sim_card_parent_class)->dispose(object);
+}
+
+static void ril_sim_card_finalize(GObject *object)
+{
+	struct ril_sim_card *self = RIL_SIMCARD(object);
+	struct ril_sim_card_priv *priv = self->priv;
+
+	grilio_channel_unref(priv->io);
+	grilio_queue_unref(priv->q);
+	ril_sim_card_status_free(self->status);
+	G_OBJECT_CLASS(ril_sim_card_parent_class)->finalize(object);
+}
+
+static void ril_sim_card_class_init(RilSimCardClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS(klass);
+
+	object_class->dispose = ril_sim_card_dispose;
+	object_class->finalize = ril_sim_card_finalize;
+	g_type_class_add_private(klass, sizeof(struct ril_sim_card_priv));
+	ril_sim_card_signals[SIGNAL_STATUS_RECEIVED] =
+		g_signal_new(SIGNAL_STATUS_RECEIVED_NAME,
+			G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
+			0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+	ril_sim_card_signals[SIGNAL_STATUS_CHANGED] =
+		g_signal_new(SIGNAL_STATUS_CHANGED_NAME,
+			G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
+			0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+	ril_sim_card_signals[SIGNAL_STATE_CHANGED] =
+		g_signal_new(SIGNAL_STATE_CHANGED_NAME,
+			G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
+			0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+	ril_sim_card_signals[SIGNAL_APP_CHANGED] =
+		g_signal_new(SIGNAL_APP_CHANGED_NAME,
+			G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
+			0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+}
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_sim_card.h

@@ -0,0 +1,81 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#ifndef RIL_SIM_CARD_H
+#define RIL_SIM_CARD_H
+
+#include "ril_types.h"
+
+struct ril_sim_card_app {
+	enum ril_app_type app_type;
+	enum ril_app_state app_state;
+	enum ril_perso_substate perso_substate;
+	char *aid;
+	char *label;
+	guint pin_replaced;
+	enum ril_pin_state pin1_state;
+	enum ril_pin_state pin2_state;
+};
+
+struct ril_sim_card_status {
+	enum ril_card_state card_state;
+	enum ril_pin_state pin_state;
+	int gsm_umts_index;
+	int cdma_index;
+	int ims_index;
+	int num_apps;
+	struct ril_sim_card_app *apps;
+};
+
+struct ril_sim_card {
+	GObject object;
+	struct ril_sim_card_priv *priv;
+	struct ril_sim_card_status *status;
+	const struct ril_sim_card_app *app;
+	guint slot;
+};
+
+typedef void (*ril_sim_card_cb_t)(struct ril_sim_card *sc, void *arg);
+
+/* Flags for ril_sim_card_new */
+#define RIL_SIM_CARD_V9_UICC_SUBSCRIPTION_WORKAROUND    (0x01)
+
+struct ril_sim_card *ril_sim_card_new(GRilIoChannel *io, guint slot, int flags);
+struct ril_sim_card *ril_sim_card_ref(struct ril_sim_card *sc);
+void ril_sim_card_unref(struct ril_sim_card *sc);
+gulong ril_sim_card_add_status_received_handler(struct ril_sim_card *sc,
+					ril_sim_card_cb_t cb, void *arg);
+gulong ril_sim_card_add_status_changed_handler(struct ril_sim_card *sc,
+					ril_sim_card_cb_t cb, void *arg);
+gulong ril_sim_card_add_state_changed_handler(struct ril_sim_card *sc,
+					ril_sim_card_cb_t cb, void *arg);
+gulong ril_sim_card_add_app_changed_handler(struct ril_sim_card *sc,
+					ril_sim_card_cb_t cb, void *arg);
+void ril_sim_card_remove_handler(struct ril_sim_card *sc, gulong id);
+
+/* Inline wrappers */
+G_INLINE_FUNC enum ril_app_type
+ril_sim_card_app_type(struct ril_sim_card *sc)
+	{ return (sc && sc->app) ? sc->app->app_type : RIL_APPTYPE_UNKNOWN; }
+
+#endif /* RIL_SIM_CARD_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_sim_dbus.c

@@ -0,0 +1,242 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_log.h"
+
+#include <ofono/dbus.h>
+
+#include <gdbus.h>
+
+#include "ofono.h"
+#include "storage.h"
+
+struct ril_sim_dbus {
+	char *path;
+	char *imsi;
+	char *name;
+	char *default_name;
+	gboolean enable_4g;
+	GKeyFile *storage;
+	DBusConnection *conn;
+	struct ril_modem *md;
+};
+
+#define RIL_SIM_STORE                   "ril"
+#define RIL_SIM_STORE_GROUP             "Settings"
+#define RIL_SIM_STORE_ENABLE_4G         "Enable4G"
+#define RIL_SIM_STORE_DISPLAY_NAME      "DisplayName"
+
+#define RIL_SIM_DBUS_INTERFACE          "org.nemomobile.ofono.SimSettings"
+#define RIL_SIM_DBUS_INTERFACE_VERSION  (1)
+
+#define RIL_SIM_DBUS_DISPLAY_NAME_CHANGED_SIGNAL    "DisplayNameChanged"
+#define RIL_SIM_DBUS_ENABLE_4G_CHANGED_SIGNAL       "Enable4GChanged"
+
+static DBusMessage *ril_sim_dbus_get_all(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	struct ril_sim_dbus *dbus = data;
+	DBusMessage *reply = dbus_message_new_method_return(msg);
+	dbus_int32_t version = RIL_SIM_DBUS_INTERFACE_VERSION;
+	dbus_bool_t enable_4g = dbus->enable_4g;
+	DBusMessageIter iter;
+
+	dbus_message_iter_init_append(reply, &iter);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &version);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &enable_4g);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &dbus->name);
+	return reply;
+}
+
+static DBusMessage *ril_sim_dbus_get_interface_version(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	DBusMessage *reply = dbus_message_new_method_return(msg);
+	dbus_int32_t version = RIL_SIM_DBUS_INTERFACE_VERSION;
+	DBusMessageIter iter;
+
+	dbus_message_iter_init_append(reply, &iter);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &version);
+	return reply;
+}
+
+static DBusMessage *ril_sim_dbus_get_enable_4g(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	struct ril_sim_dbus *dbus = data;
+	DBusMessage *reply = dbus_message_new_method_return(msg);
+	dbus_bool_t enable_4g = dbus->enable_4g;
+	DBusMessageIter iter;
+
+	dbus_message_iter_init_append(reply, &iter);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &enable_4g);
+	return reply;
+}
+
+static DBusMessage *ril_sim_dbus_get_display_name(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	struct ril_sim_dbus *dbus = data;
+	DBusMessage *reply = dbus_message_new_method_return(msg);
+	DBusMessageIter iter;
+
+	dbus_message_iter_init_append(reply, &iter);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &dbus->name);
+	return reply;
+}
+
+static void ril_sim_dbus_update_display_name(struct ril_sim_dbus *dbus,
+							const char *name)
+{
+	if (g_strcmp0(dbus->name, name)) {
+		g_free(dbus->name);
+		dbus->name = g_strdup(name);
+		g_key_file_set_string(dbus->storage, RIL_SIM_STORE_GROUP,
+					RIL_SIM_STORE_DISPLAY_NAME, name);
+		storage_sync(dbus->imsi, RIL_SIM_STORE, dbus->storage);
+		g_dbus_emit_signal(dbus->conn, dbus->path,
+				RIL_SIM_DBUS_INTERFACE,
+				RIL_SIM_DBUS_DISPLAY_NAME_CHANGED_SIGNAL,
+				DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);
+	}
+}
+
+static DBusMessage *ril_sim_dbus_set_display_name(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	DBusMessageIter iter;
+
+	dbus_message_iter_init(msg, &iter);
+	if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING) {
+		struct ril_sim_dbus *dbus = data;
+		DBusBasicValue value;
+		const char *name;
+
+		dbus_message_iter_get_basic(&iter, &value);
+		name = value.str;
+		if (!name || !name[0]) name = dbus->default_name;
+		ril_sim_dbus_update_display_name(dbus, name);
+		return dbus_message_new_method_return(msg);
+	} else {
+		return __ofono_error_invalid_args(msg);
+	}
+}
+
+static const GDBusMethodTable ril_sim_dbus_methods[] = {
+	{ GDBUS_METHOD("GetAll",
+			NULL, GDBUS_ARGS({ "settings", "ibs" }),
+			ril_sim_dbus_get_all) },
+	{ GDBUS_METHOD("GetInterfaceVersion",
+			NULL, GDBUS_ARGS({ "version", "i" }),
+			ril_sim_dbus_get_interface_version) },
+	{ GDBUS_METHOD("GetEnable4G",
+			NULL, GDBUS_ARGS({ "enable", "b" }),
+			ril_sim_dbus_get_enable_4g) },
+	{ GDBUS_METHOD("GetDisplayName",
+			NULL, GDBUS_ARGS({ "name", "s" }),
+			ril_sim_dbus_get_display_name) },
+	{ GDBUS_METHOD("SetDisplayName",
+			GDBUS_ARGS({ "name", "s" }), NULL,
+			ril_sim_dbus_set_display_name) },
+	{ }
+};
+
+static const GDBusSignalTable ril_sim_dbus_signals[] = {
+	{ GDBUS_SIGNAL(RIL_SIM_DBUS_DISPLAY_NAME_CHANGED_SIGNAL,
+			GDBUS_ARGS({ "name", "s" })) },
+	{ GDBUS_SIGNAL(RIL_SIM_DBUS_ENABLE_4G_CHANGED_SIGNAL,
+			GDBUS_ARGS({ "enabled", "b" })) },
+	{ }
+};
+
+const char *ril_sim_dbus_imsi(struct ril_sim_dbus *dbus)
+{
+	return dbus ? dbus->imsi : NULL;
+}
+
+struct ril_sim_dbus *ril_sim_dbus_new(struct ril_modem *md)
+{
+	const char *imsi = ofono_sim_get_imsi(ril_modem_ofono_sim(md));
+
+	if (imsi) {
+		GError *error = NULL;
+		const struct ril_slot_config *config = &md->config;
+		struct ril_sim_dbus *dbus = g_new0(struct ril_sim_dbus, 1);
+
+		DBG("%s", ril_modem_get_path(md));
+		dbus->md = md;
+		dbus->conn = dbus_connection_ref(ofono_dbus_get_connection());
+		dbus->path = g_strdup(ril_modem_get_path(md));
+		dbus->imsi = g_strdup(imsi);
+		dbus->default_name = g_strdup(config->default_name);
+
+		/* Load settings */
+		dbus->storage = storage_open(imsi, RIL_SIM_STORE);
+		dbus->enable_4g = g_key_file_get_boolean(dbus->storage,
+			RIL_SIM_STORE_GROUP, RIL_SIM_STORE_ENABLE_4G, &error);
+		if (error) {
+			dbus->enable_4g = config->enable_4g;
+			g_error_free(error);
+			error = NULL;
+		}
+		dbus->name = g_key_file_get_string(dbus->storage,
+			RIL_SIM_STORE_GROUP, RIL_SIM_STORE_DISPLAY_NAME, NULL);
+		if (!dbus->name) {
+			dbus->name = g_strdup(config->default_name);
+			GASSERT(dbus->name);
+		}
+
+		/* Register D-Bus interface */
+		if (g_dbus_register_interface(dbus->conn, dbus->path,
+				RIL_SIM_DBUS_INTERFACE, ril_sim_dbus_methods,
+				ril_sim_dbus_signals, NULL, dbus, NULL)) {
+			ofono_modem_add_interface(md->ofono,
+						RIL_SIM_DBUS_INTERFACE);
+			return dbus;
+		} else {
+			ofono_error("RIL D-Bus register failed");
+			ril_sim_dbus_free(dbus);
+		}
+	}
+
+	return NULL;
+}
+
+void ril_sim_dbus_free(struct ril_sim_dbus *dbus)
+{
+	if (dbus) {
+		DBG("%s", dbus->path);
+		g_dbus_unregister_interface(dbus->conn, dbus->path,
+						RIL_SIM_DBUS_INTERFACE);
+		ofono_modem_remove_interface(dbus->md->ofono,
+						RIL_SIM_DBUS_INTERFACE);
+		dbus_connection_unref(dbus->conn);	
+		g_key_file_free(dbus->storage);
+		g_free(dbus->path);
+		g_free(dbus->imsi);
+		g_free(dbus->name);
+		g_free(dbus->default_name);
+		g_free(dbus);
+	}
+}
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_sms.c

@@ -0,0 +1,498 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_constants.h"
+#include "ril_util.h"
+#include "ril_log.h"
+
+#include "smsutil.h"
+#include "util.h"
+#include "simutil.h"
+
+#define SIM_EFSMS_FILEID        0x6F3C
+#define EFSMS_LENGTH            176
+
+#define TYPE_LOCAL              129
+#define TYPE_INTERNATIONAL      145
+
+static unsigned char path[4] = {0x3F, 0x00, 0x7F, 0x10};
+
+enum ril_sms_events {
+	SMS_EVENT_NEW_SMS,
+	SMS_EVENT_NEW_STATUS_REPORT,
+	SMS_EVENT_NEW_SMS_ON_SIM,
+	SMS_EVENT_COUNT
+};
+
+struct ril_sms {
+	GRilIoChannel *io;
+	GRilIoQueue *q;
+	struct ril_modem *modem;
+	struct ofono_sms *sms;
+	gulong event_id[SMS_EVENT_COUNT];
+	guint timer_id;
+};
+
+struct ril_sms_cbd {
+	union _ofono_sms_cb {
+		ofono_sms_sca_set_cb_t sca_set;
+		ofono_sms_sca_query_cb_t sca_query;
+		ofono_sms_submit_cb_t submit;
+		gpointer ptr;
+	} cb;
+	gpointer data;
+};
+
+struct ril_sms_on_sim_req {
+	struct ril_sms *sd;
+	int record;
+};
+
+#define ril_sms_cbd_free g_free
+#define ril_sms_on_sim_req_free g_free
+
+static inline struct ril_sms *ril_sms_get_data(struct ofono_sms *sms)
+{
+	return ofono_sms_get_data(sms);
+}
+
+struct ril_sms_cbd *ril_sms_cbd_new(struct ril_sms *sd, void *cb, void *data)
+{
+	struct ril_sms_cbd *cbd = g_new0(struct ril_sms_cbd, 1);
+
+	cbd->cb.ptr = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+struct ril_sms_on_sim_req *ril_sms_on_sim_req_new(struct ril_sms *sd, int rec)
+{
+	struct ril_sms_on_sim_req *cbd = g_new0(struct ril_sms_on_sim_req, 1);
+
+	cbd->sd = sd;
+	cbd->record = rec;
+	return cbd;
+}
+
+static void ril_sms_sca_set_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_sms_cbd *cbd = user_data;
+	ofono_sms_sca_set_cb_t cb = cbd->cb.sca_set;
+
+	if (status == RIL_E_SUCCESS) {
+		cb(ril_error_ok(&error), cbd->data);
+	} else {
+		ofono_error("csca setting failed");
+		cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static void ril_sms_sca_set(struct ofono_sms *sms,
+			const struct ofono_phone_number *sca,
+			ofono_sms_sca_set_cb_t cb, void *data)
+{
+	struct ril_sms *sd = ril_sms_get_data(sms);
+	GRilIoRequest *req = grilio_request_new();
+	char number[OFONO_MAX_PHONE_NUMBER_LENGTH + 4];
+
+	if (sca->type == TYPE_LOCAL) {
+		snprintf(number, sizeof(number), "\"%s\"", sca->number);
+	} else {
+		snprintf(number, sizeof(number), "\"+%s\"", sca->number);
+	}
+
+	DBG("Setting sca: %s", number);
+	grilio_request_append_utf8(req, number);
+	grilio_queue_send_request_full(sd->q, req,
+			RIL_REQUEST_SET_SMSC_ADDRESS, ril_sms_sca_set_cb,
+			ril_sms_cbd_free, ril_sms_cbd_new(sd, cb, data));
+	grilio_request_unref(req);
+}
+
+static void ril_sms_sca_query_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_sms_cbd *cbd = user_data;
+	ofono_sms_sca_query_cb_t cb = cbd->cb.sca_query;
+	struct ofono_error error;
+	GRilIoParser rilp;
+	gchar *temp_buf;
+
+	if (status != RIL_E_SUCCESS) {
+		ofono_error("csca query failed");
+		cb(ril_error_failure(&error), NULL, cbd->data);
+		return;
+	}
+
+	grilio_parser_init(&rilp, data, len);
+	temp_buf = grilio_parser_get_utf8(&rilp);
+
+	if (temp_buf) {
+		/* RIL gives address in quotes */
+		gchar *number = strtok(temp_buf, "\"");
+		struct ofono_phone_number sca;
+
+		strncpy(sca.number, number, OFONO_MAX_PHONE_NUMBER_LENGTH);
+		sca.number[OFONO_MAX_PHONE_NUMBER_LENGTH] = '\0';
+		if (sca.number[0] == '+') {
+			number = number + 1;
+			sca.type = TYPE_INTERNATIONAL;
+		} else {
+			sca.type = TYPE_LOCAL;
+		}
+
+		DBG("csca_query_cb: %s, %d", sca.number, sca.type);
+		cb(ril_error_ok(&error), &sca, cbd->data);
+		g_free(temp_buf);
+	} else {
+		ofono_error("return value invalid");
+		cb(ril_error_failure(&error), NULL, cbd->data);
+	}
+}
+
+static void ril_sms_sca_query(struct ofono_sms *sms,
+			ofono_sms_sca_query_cb_t cb, void *data)
+{
+	struct ril_sms *sd = ril_sms_get_data(sms);
+
+	DBG("Sending csca_query");
+	grilio_queue_send_request_full(sd->q, NULL,
+			RIL_REQUEST_GET_SMSC_ADDRESS, ril_sms_sca_query_cb,
+			ril_sms_cbd_free, ril_sms_cbd_new(sd, cb, data));
+}
+
+static void ril_sms_submit_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_sms_cbd *cbd = user_data;
+	ofono_sms_submit_cb_t cb = cbd->cb.submit;
+	struct ofono_error error;
+	int mr = 0;
+
+	if (status == RIL_E_SUCCESS) {
+		GRilIoParser rilp;
+		int err = -1;
+
+		grilio_parser_init(&rilp, data, len);
+
+		/* TP-Message-Reference for GSM/
+		 * BearerData MessageId for CDMA
+		 */
+		grilio_parser_get_int32(&rilp, &mr);
+		grilio_parser_skip_string(&rilp);
+
+		/* error: 3GPP 27.005, 3.2.5, -1 if unknown or not applicable */
+		grilio_parser_get_int32(&rilp, &err);
+		DBG("sms msg ref: %d, error: %d", mr, err);
+		ril_error_init_ok(&error);
+	} else if (status == RIL_E_GENERIC_FAILURE) {
+		ofono_info("not allowed by MO SMS control, do not retry");
+		error.type = OFONO_ERROR_TYPE_CMS;
+		error.error = 500;
+	} else {
+		ofono_error("sms sending failed, retry");
+		ril_error_init_failure(&error);
+	}
+
+	cb(&error, mr, cbd->data);
+}
+
+static void ril_sms_submit(struct ofono_sms *sms, const unsigned char *pdu,
+			int pdu_len, int tpdu_len, int mms,
+			ofono_sms_submit_cb_t cb, void *data)
+{
+	struct ril_sms *sd = ril_sms_get_data(sms);
+	GRilIoRequest *req = grilio_request_new();
+	int smsc_len;
+	char *tpdu;
+
+	DBG("pdu_len: %d, tpdu_len: %d mms: %d", pdu_len, tpdu_len, mms);
+
+	grilio_request_append_int32(req, 2);     /* Number of strings */
+
+	/* SMSC address:
+	 *
+	 * smsc_len == 1, then zero-length SMSC was spec'd
+	 * RILD expects a NULL string in this case instead
+	 * of a zero-length string.
+	 */
+	smsc_len = pdu_len - tpdu_len;
+	if (smsc_len > 1) {
+		/* TODO: encode SMSC & write to parcel */
+		DBG("SMSC address specified (smsc_len %d); NOT-IMPLEMENTED",
+								smsc_len);
+	}
+
+	grilio_request_append_utf8(req, NULL); /* default SMSC address */
+
+	/* TPDU:
+	 *
+	 * 'pdu' is a raw hexadecimal string
+	 *  encode_hex() turns it into an ASCII/hex UTF8 buffer
+	 *  grilio_request_append_utf8() encodes utf8 -> utf16
+	 */
+	tpdu = encode_hex(pdu + smsc_len, tpdu_len, 0);
+	grilio_request_append_utf8(req, tpdu);
+
+	DBG("%s", tpdu);
+	grilio_queue_send_request_full(sd->q, req,
+			RIL_REQUEST_SEND_SMS, ril_sms_submit_cb,
+			ril_sms_cbd_free, ril_sms_cbd_new(sd, cb, data));
+	grilio_request_unref(req);
+	g_free(tpdu);
+}
+
+static void ril_ack_delivery_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	if (status != RIL_E_SUCCESS) {
+		ofono_error("SMS acknowledgement failed: "
+				"Further SMS reception is not guaranteed");
+	}
+}
+
+static void ril_ack_delivery(struct ril_sms *sd, gboolean error)
+{
+	GRilIoRequest *req = grilio_request_sized_new(12);
+	const int code = (error ? 0 : 0xff);
+
+	DBG("(%d,%d)", error, code);
+	grilio_request_append_int32(req, 2);     /* Array size*/
+	grilio_request_append_int32(req, error); /* Success (1)/Failure (0) */
+	grilio_request_append_int32(req, code);  /* error code */
+
+	/* ACK the incoming NEW_SMS */
+	grilio_queue_send_request_full(sd->q, req,
+		RIL_REQUEST_SMS_ACKNOWLEDGE, ril_ack_delivery_cb, NULL, NULL);
+	grilio_request_unref(req);
+}
+
+static void ril_sms_notify(GRilIoChannel *io, guint ril_event,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_sms *sd = user_data;
+	GRilIoParser rilp;
+	char *ril_pdu;
+	int ril_pdu_len;
+	unsigned int smsc_len;
+	long ril_buf_len;
+	guchar *ril_data;
+
+	ril_pdu = NULL;
+	ril_data = NULL;
+
+	DBG("event: %d; data_len: %d", ril_event, len);
+
+	grilio_parser_init(&rilp, data, len);
+	ril_pdu = grilio_parser_get_utf8(&rilp);
+	if (ril_pdu == NULL)
+		goto error;
+
+	ril_pdu_len = strlen(ril_pdu);
+
+	DBG("ril_pdu_len is %d", ril_pdu_len);
+	ril_data = decode_hex(ril_pdu, ril_pdu_len, &ril_buf_len, -1);
+	if (ril_data == NULL)
+		goto error;
+
+	/* The first octect in the pdu contains the SMSC address length
+	 * which is the X following octects it reads. We add 1 octet to
+	 * the read length to take into account this read octet in order
+	 * to calculate the proper tpdu length.
+	 */
+	smsc_len = ril_data[0] + 1;
+	ofono_info("sms received, smsc_len is %d", smsc_len);
+	DBG("(%s)", ril_pdu);
+
+	if (ril_event == RIL_UNSOL_RESPONSE_NEW_SMS) {
+		/* Last parameter is 'tpdu_len' ( substract SMSC length ) */
+		ofono_sms_deliver_notify(sd->sms, ril_data, ril_buf_len,
+						ril_buf_len - smsc_len);
+	} else {
+		GASSERT(ril_event == RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT);
+		ofono_sms_status_notify(sd->sms, ril_data, ril_buf_len,
+						ril_buf_len - smsc_len);
+	}
+
+	g_free(ril_pdu);
+	g_free(ril_data);
+	ril_ack_delivery(sd, TRUE);
+	return;
+
+error:
+	g_free(ril_pdu);
+	g_free(ril_data);
+	ril_ack_delivery(sd, FALSE);
+	ofono_error("Unable to parse NEW_SMS notification");
+}
+
+static void ril_new_sms_on_sim_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	DBG("%d", status);
+	if (status == RIL_E_SUCCESS) {
+		ofono_info("sms deleted from sim");
+	} else {
+		ofono_error("deleting sms from sim failed");
+	}
+}
+
+static void ril_request_delete_sms_om_sim(struct ril_sms *sd, int record)
+{
+	GRilIoRequest *req = grilio_request_sized_new(8);
+
+	DBG("Deleting record: %d", record);
+
+	grilio_request_append_int32(req, 1);        /* Array length */
+	grilio_request_append_int32(req, record);
+	grilio_queue_send_request_full(sd->q, req,
+			RIL_REQUEST_DELETE_SMS_ON_SIM,
+			ril_new_sms_on_sim_cb, NULL, NULL);
+	grilio_request_unref(req);
+}
+
+static void ril_sms_on_sim_cb(const struct ofono_error *error,
+					const unsigned char *sdata,
+					int length, void *data)
+{
+	struct ril_sms_on_sim_req *cbd = data;
+	struct ril_sms *sd = cbd->sd;
+
+	/*
+	 * It seems when reading EFsms RIL returns the whole record including
+	 * the first status byte therefore we ignore that as we are only
+	 * interested of the following pdu
+	 */
+	/* The first octect in the pdu contains the SMSC address length
+	 * which is the X following octects it reads. We add 1 octet to
+	 * the read length to take into account this read octet in order
+	 * to calculate the proper tpdu length.
+	 */
+	if (error->type == OFONO_ERROR_TYPE_NO_ERROR) {
+		unsigned int smsc_len = sdata[1] + 1;
+		ofono_sms_deliver_notify(sd->sms, sdata + 1, length - 1,
+						length - smsc_len - 1);
+		ril_request_delete_sms_om_sim(sd, cbd->record);
+	} else {
+		ofono_error("cannot read sms from sim");
+	}
+
+	ril_sms_on_sim_req_free(cbd);
+}
+
+static void ril_sms_on_sim(GRilIoChannel *io, guint ril_event,
+			const void *data, guint len, void *user_data)
+{
+	struct ril_sms *sd = user_data;
+	struct ofono_sim *sim = ril_modem_ofono_sim(sd->modem);
+	int data_len = 0, rec = 0;
+	GRilIoParser rilp;
+
+	ofono_info("new sms on sim");
+	grilio_parser_init(&rilp, data, len);
+	if (sim &&
+		grilio_parser_get_int32(&rilp, &data_len) && data_len > 0 &&
+		grilio_parser_get_int32(&rilp, &rec)) {
+		DBG("rec %d", rec);
+		ril_sim_read_file_linear(sim, SIM_EFSMS_FILEID, rec,
+				EFSMS_LENGTH, path, sizeof(path),
+				ril_sms_on_sim_cb,
+				ril_sms_on_sim_req_new(sd,rec));
+	}
+}
+
+static gboolean ril_sms_register(gpointer user_data)
+{
+	struct ril_sms *sd = user_data;
+
+	DBG("");
+	GASSERT(sd->timer_id);
+	sd->timer_id = 0;
+	ofono_sms_register(sd->sms);
+
+	/* Register event handlers */
+	sd->event_id[SMS_EVENT_NEW_SMS] =
+		grilio_channel_add_unsol_event_handler(sd->io, ril_sms_notify,
+			RIL_UNSOL_RESPONSE_NEW_SMS, sd);
+	sd->event_id[SMS_EVENT_NEW_STATUS_REPORT] =
+		grilio_channel_add_unsol_event_handler(sd->io, ril_sms_notify,
+			RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT, sd);
+	sd->event_id[SMS_EVENT_NEW_SMS_ON_SIM] =
+		grilio_channel_add_unsol_event_handler(sd->io, ril_sms_on_sim,
+			RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM, sd);
+
+	/* Single-shot */
+	return FALSE;
+}
+
+static int ril_sms_probe(struct ofono_sms *sms, unsigned int vendor,
+								void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_sms *sd = g_new0(struct ril_sms, 1);
+
+	sd->modem = modem;
+	sd->sms = sms;
+	sd->io = grilio_channel_ref(ril_modem_io(modem));
+	sd->q = grilio_queue_new(sd->io);
+	sd->timer_id = g_idle_add(ril_sms_register, sd);
+	ofono_sms_set_data(sms, sd);
+	return 0;
+}
+
+static void ril_sms_remove(struct ofono_sms *sms)
+{
+	int i;
+	struct ril_sms *sd = ril_sms_get_data(sms);
+
+	DBG("");
+	ofono_sms_set_data(sms, NULL);
+
+	for (i=0; i<G_N_ELEMENTS(sd->event_id); i++) {
+		grilio_channel_remove_handler(sd->io, sd->event_id[i]);
+
+	}
+
+	if (sd->timer_id > 0) {
+		g_source_remove(sd->timer_id);
+	}
+
+	grilio_channel_unref(sd->io);
+	grilio_queue_cancel_all(sd->q, FALSE);
+	grilio_queue_unref(sd->q);
+	g_free(sd);
+}
+
+const struct ofono_sms_driver ril_sms_driver = {
+	.name           = RILMODEM_DRIVER,
+	.probe          = ril_sms_probe,
+	.remove         = ril_sms_remove,
+	.sca_query      = ril_sms_sca_query,
+	.sca_set        = ril_sms_sca_set,
+	.submit         = ril_sms_submit,
+	.bearer_query   = NULL,          /* FIXME: needs investigation. */
+	.bearer_set     = NULL
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_stk.c

@@ -0,0 +1,303 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_util.h"
+#include "ril_log.h"
+#include "ril_constants.h"
+
+#include "util.h"
+
+#ifndef UI_LANG
+#  define UI_LANG "/var/lib/environment/nemo/locale.conf"
+#endif
+
+enum ril_stk_events {
+	STK_EVENT_PROACTIVE_COMMAND,
+	STK_EVENT_SESSION_END,
+	STK_EVENT_NOTIFY,
+	STK_EVENT_COUNT
+};
+
+struct ril_stk {
+	struct ofono_stk *stk;
+	GRilIoChannel *io;
+	GRilIoQueue *q;
+	gulong event_id[STK_EVENT_COUNT];
+};
+
+struct ril_stk_cbd {
+	union _ofono_stk_cb {
+		ofono_stk_envelope_cb_t envelope;
+		ofono_stk_generic_cb_t generic;
+		gpointer ptr;
+	} cb;
+	gpointer data;
+};
+
+#define ril_stk_cbd_free g_free
+
+static inline struct ril_stk *ril_stk_get_data(struct ofono_stk *stk)
+{
+	return ofono_stk_get_data(stk);
+}
+
+struct ril_stk_cbd *ril_stk_cbd_new(void *cb, void *data)
+{
+	struct ril_stk_cbd *cbd = g_new0(struct ril_stk_cbd, 1);
+
+	cbd->cb.ptr = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+static void ril_stk_envelope_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_stk_cbd *cbd = user_data;
+	ofono_stk_envelope_cb_t cb = cbd->cb.envelope;
+
+	if (status == RIL_E_SUCCESS) {
+		DBG("%u bytes(s)", len);
+		cb(ril_error_ok(&error), NULL, 0, cbd->data);
+	} else {
+		DBG("Envelope reply failure: %s", ril_error_to_string(status));
+		cb(ril_error_failure(&error), NULL, 0, cbd->data);
+	}
+}
+
+static void ril_stk_envelope(struct ofono_stk *stk, int length,
+	const unsigned char *cmd, ofono_stk_envelope_cb_t cb, void *data)
+{
+	struct ril_stk *sd = ril_stk_get_data(stk);
+	GRilIoRequest *req = grilio_request_new();
+	char *hex_envelope = encode_hex(cmd, length, 0);
+
+	DBG("%s", hex_envelope);
+	grilio_request_append_utf8(req, hex_envelope);
+	g_free(hex_envelope);
+	grilio_queue_send_request_full(sd->q, req,
+			RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND,
+			ril_stk_envelope_cb, ril_stk_cbd_free,
+			ril_stk_cbd_new(cb, data));
+	grilio_request_unref(req);
+}
+
+static void ril_stk_terminal_response_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_stk_cbd *cbd = user_data;
+	ofono_stk_generic_cb_t cb = cbd->cb.generic;
+
+	DBG("");
+	if (status == RIL_E_SUCCESS) {
+		cb(ril_error_ok(&error), cbd->data);
+	} else {
+		ofono_error("Error in sending terminal response");
+		cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static void ril_stk_terminal_response(struct ofono_stk *stk, int length,
+					const unsigned char *resp,
+					ofono_stk_generic_cb_t cb, void *data)
+{
+	struct ril_stk *sd = ril_stk_get_data(stk);
+	GRilIoRequest *req = grilio_request_new();
+	char *hex_tr = encode_hex(resp, length, 0);
+
+	DBG("rilmodem terminal response: %s", hex_tr);
+	grilio_request_append_utf8(req, hex_tr);
+	g_free(hex_tr);
+	grilio_queue_send_request_full(sd->q, req,
+				RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE,
+				ril_stk_terminal_response_cb,
+				ril_stk_cbd_free, ril_stk_cbd_new(cb, data));
+	grilio_request_unref(req);
+}
+
+static void ril_stk_user_confirmation(struct ofono_stk *stk,
+					ofono_bool_t confirm)
+{
+	struct ril_stk *sd = ril_stk_get_data(stk);
+	GRilIoRequest *req = grilio_request_sized_new(8);
+
+	DBG("%d", confirm);
+	grilio_request_append_int32(req, 1);            /* size of array */
+	grilio_request_append_int32(req, confirm);      /* yes/no */
+
+	grilio_queue_send_request(sd->q, req,
+		RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM);
+	grilio_request_unref(req);
+}
+
+static void ril_stk_pcmd_notify(GRilIoChannel *io, guint code,
+			const void *data, guint data_len, void *user_data)
+{
+	struct ril_stk *sd = user_data;
+	GRilIoParser rilp;
+	char *pcmd;
+	guchar *pdu;
+	long len = 0;
+
+	GASSERT(code == RIL_UNSOL_STK_PROACTIVE_COMMAND);
+	grilio_parser_init(&rilp, data, data_len);
+	pcmd = grilio_parser_get_utf8(&rilp);
+	DBG("pcmd: %s", pcmd);
+
+	pdu = decode_hex(pcmd, strlen(pcmd), &len, -1);
+	g_free(pcmd);
+
+	ofono_stk_proactive_command_notify(sd->stk, len, pdu);
+	g_free(pdu);
+}
+
+static void ril_stk_event_notify(GRilIoChannel *io, guint code,
+			const void *data, guint data_len, void *user_data)
+{
+	struct ril_stk *sd = user_data;
+	GRilIoParser rilp;
+	char *pcmd = NULL;
+	guchar *pdu = NULL;
+	long len;
+
+	/* Proactive command has been handled by the modem. */
+	GASSERT(code == RIL_UNSOL_STK_EVENT_NOTIFY);
+	grilio_parser_init(&rilp, data, data_len);
+	pcmd = grilio_parser_get_utf8(&rilp);
+	DBG("pcmd: %s", pcmd);
+	pdu = decode_hex(pcmd, strlen(pcmd), &len, -1);
+	g_free(pcmd);
+
+	ofono_stk_proactive_command_handled_notify(sd->stk, len, pdu);
+	g_free(pdu);
+}
+
+static void ril_stk_session_end_notify(GRilIoChannel *io, guint code,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_stk *sd = user_data;
+
+	DBG("");
+	GASSERT(code == RIL_UNSOL_STK_SESSION_END);
+	ofono_stk_proactive_session_end_notify(sd->stk);
+}
+
+static void ril_stk_agent_ready(struct ofono_stk *stk)
+{
+	struct ril_stk *sd = ril_stk_get_data(stk);
+
+	DBG("");
+	if (!sd->event_id[STK_EVENT_PROACTIVE_COMMAND]) {
+		DBG("Subscribing notifications");
+		sd->event_id[STK_EVENT_PROACTIVE_COMMAND] =
+			grilio_channel_add_unsol_event_handler(sd->io,
+				ril_stk_pcmd_notify,
+				RIL_UNSOL_STK_PROACTIVE_COMMAND, sd);
+
+		GASSERT(!sd->event_id[STK_EVENT_SESSION_END]);
+		sd->event_id[STK_EVENT_SESSION_END] =
+			grilio_channel_add_unsol_event_handler(sd->io,
+				ril_stk_session_end_notify,
+				RIL_UNSOL_STK_SESSION_END, sd);
+
+		GASSERT(!sd->event_id[STK_EVENT_NOTIFY]);
+		sd->event_id[STK_EVENT_NOTIFY] =
+			grilio_channel_add_unsol_event_handler(sd->io,
+				ril_stk_event_notify, 
+				RIL_UNSOL_STK_EVENT_NOTIFY, sd);
+
+		grilio_queue_send_request(sd->q, NULL,
+				RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING);
+	}
+}
+
+static void ril_stk_set_lang()
+{
+	GError *error = NULL;
+	GIOChannel* chan = g_io_channel_new_file(UI_LANG, "r", &error);
+	if (chan) {
+		GString* buf = g_string_new(NULL);
+		gsize term;
+		while (g_io_channel_read_line_string(chan, buf, &term, NULL) ==
+							G_IO_STATUS_NORMAL) {
+			char* lang;
+			g_string_set_size(buf, term);
+			lang = strstr(buf->str, "LANG=");
+			if (lang) {
+				setenv("LANG", lang + 5, TRUE);
+			}
+		}
+		g_string_free(buf, TRUE);
+		g_io_channel_unref(chan);
+	} else {
+		DBG("%s: %s", UI_LANG, error->message);
+		g_error_free(error);
+	}
+}
+
+static int ril_stk_probe(struct ofono_stk *stk, unsigned int vendor, void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_stk *sd = g_new0(struct ril_stk, 1);
+
+	DBG("");
+	sd->stk = stk;
+	sd->io = grilio_channel_ref(ril_modem_io(modem));
+	sd->q = grilio_queue_new(sd->io);
+
+	ofono_stk_set_data(stk, sd);
+	ofono_stk_register(stk);
+	ril_stk_set_lang();
+	return 0;
+}
+
+static void ril_stk_remove(struct ofono_stk *stk)
+{
+	struct ril_stk *sd = ril_stk_get_data(stk);
+	int i;
+
+	DBG("");
+	ofono_stk_set_data(stk, NULL);
+
+	for (i=0; i<G_N_ELEMENTS(sd->event_id); i++) {
+		grilio_channel_remove_handler(sd->io, sd->event_id[i]);
+	}
+
+	grilio_channel_unref(sd->io);
+	grilio_queue_cancel_all(sd->q, FALSE);
+	grilio_queue_unref(sd->q);
+	g_free(sd);
+}
+
+const struct ofono_stk_driver ril_stk_driver = {
+	.name                   = RILMODEM_DRIVER,
+	.probe                  = ril_stk_probe,
+	.remove                 = ril_stk_remove,
+	.envelope               = ril_stk_envelope,
+	.terminal_response      = ril_stk_terminal_response,
+	.user_confirmation      = ril_stk_user_confirmation,
+	.ready                  = ril_stk_agent_ready
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_subscription.conf

@@ -0,0 +1,55 @@
+# This is a sample configuration file for the ril driver
+#
+# This file is expected to be installed in /etc/ofono
+#
+# Configuration for each modem is defined in its own [ril_x] section.
+# Only the sections that start with the "ril_" prefix define the modems,
+# other sections are currently ignored.
+#
+
+[ril_0]
+
+# Required entry, defines the RIL socket path
+socket=/dev/socket/rild
+
+# Subscription string. Some (mostly, older) RILs require that 4 bytes
+# (usually SUB1 or SUB2) are written to the socket before rild starts
+# talking to us.
+#
+# Not sent by default.
+#
+#sub=SUB1
+
+# RIL logging prefix, to tell one socket from another in the log.
+# Makes sense if you have more than one modem configured.
+#
+# No prefix by default.
+#
+#name=RIL1
+
+# Slot id for SET_UICC_SUBSCRIPTION request.
+#
+# By default the first modem becomes slot 0, the next one slot 1 and so on.
+#
+#slot=0
+
+# RIL request timeout, in milliseconds.
+#
+# The default is zero (no timeout)
+#
+#timeout=0
+
+# Setting this one to false would disable 4G technology selection.
+#
+# By default 4G is enabled
+#
+#enable4G=true
+
+# RIL_REQUEST_SET_UICC_SUBSCRIPTION is 115 in RIL version 9 (or earlier)
+# and 122 in RIL version 10 and later. Since ofono doesn't know in advance
+# which RIL version it's dealing with, it makes the decision at runtime.
+# Settings it to false disables the workaround and always sends 122.
+#
+# Default is true (select SET_UICC_SUBSCRIPTION based on the RIL version)
+#
+#uiccWorkaround=true

ofono/drivers/ril/ril_types.h

@@ -0,0 +1,56 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#ifndef RIL_TYPES_H
+#define RIL_TYPES_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <grilio_types.h>
+#include <gutil_macros.h>
+
+#include <ofono/types.h>
+
+struct ofono_modem;
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "ril_constants.h"
+
+#define RIL_RETRY_SECS (2)
+#define RIL_RETRY_MS   (RIL_RETRY_SECS*1000)
+
+struct ril_data;
+struct ril_modem;
+struct ril_radio;
+struct ril_network;
+struct ril_sim_card;
+struct ril_plugin_dbus;
+
+#endif /* RIL_TYPES_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_ussd.c

@@ -0,0 +1,224 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_util.h"
+#include "ril_log.h"
+#include "ril_constants.h"
+
+#include "smsutil.h"
+#include "util.h"
+
+struct ril_ussd {
+	struct ofono_ussd *ussd;
+	GRilIoChannel *io;
+	GRilIoQueue *q;
+	guint timer_id;
+	gulong event_id;
+};
+
+struct ril_ussd_cbd {
+	ofono_ussd_cb_t cb;
+	gpointer data;
+};
+
+#define ril_ussd_cbd_free g_free
+
+static inline struct ril_ussd *ril_ussd_get_data(struct ofono_ussd *ussd)
+{
+	return ofono_ussd_get_data(ussd);
+}
+
+static struct ril_ussd_cbd *ril_ussd_cbd_new(ofono_ussd_cb_t cb, void *data)
+{
+	struct ril_ussd_cbd *cbd = g_new0(struct ril_ussd_cbd, 1);
+
+	cbd->cb = cb;
+	cbd->data = data;
+	return cbd;
+}
+
+static void ril_ussd_cb(GRilIoChannel *io, int status,
+			const void *data, guint len, void *user_data)
+{
+	struct ofono_error error;
+	struct ril_ussd_cbd *cbd = user_data;
+
+	if (status == RIL_E_SUCCESS) {
+		cbd->cb(ril_error_ok(&error), cbd->data);
+	} else {
+		cbd->cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static void ril_ussd_request(struct ofono_ussd *ussd, int dcs,
+	const unsigned char *pdu, int len, ofono_ussd_cb_t cb, void *data)
+{
+	struct ofono_error error;
+	enum sms_charset charset;
+	struct ril_ussd *ud = ril_ussd_get_data(ussd);
+
+	ofono_info("send ussd, len:%d", len);
+	if (cbs_dcs_decode(dcs, NULL, NULL, &charset, NULL, NULL, NULL)) {
+		if (charset == SMS_CHARSET_7BIT) {
+			unsigned char unpacked_buf[182];
+			long written = 0;
+
+			unpack_7bit_own_buf(pdu, len, 0, TRUE,
+					sizeof(unpacked_buf)-1, &written, 0,
+					unpacked_buf);
+
+			unpacked_buf[written] = 0;
+			if (written >= 1) {
+				/*
+				 * When USSD was packed, additional CR
+				 * might have been added (according to
+				 * 23.038 6.1.2.3.1). So if the last
+				 * character is CR, it should be removed
+				 * here.
+				 *
+				 * Over 2 characters long USSD string must
+				 * end with # (checked in valid_ussd_string),
+				 * so it should be safe to remove extra CR.
+				 */
+				GRilIoRequest *req = grilio_request_new();
+				int length = strlen((char *)unpacked_buf);
+				while (length > 2 &&
+					unpacked_buf[length-1] == '\r') {
+					unpacked_buf[--length] = 0;
+				}
+				grilio_request_append_utf8_chars(req, (char*)
+						unpacked_buf, length);
+				grilio_queue_send_request_full(ud->q, req,
+					RIL_REQUEST_SEND_USSD, ril_ussd_cb,
+					ril_ussd_cbd_free,
+					ril_ussd_cbd_new(cb, data));
+				grilio_request_unref(req);
+				return;
+			}
+		}
+	}
+
+	cb(ril_error_failure(&error), data);
+}
+
+static void ril_ussd_cancel(struct ofono_ussd *ussd,
+				ofono_ussd_cb_t cb, void *data)
+{
+	struct ril_ussd *ud = ril_ussd_get_data(ussd);
+
+	ofono_info("send ussd cancel");
+	grilio_queue_send_request_full(ud->q, NULL, RIL_REQUEST_CANCEL_USSD,
+		ril_ussd_cb, ril_ussd_cbd_free, ril_ussd_cbd_new(cb, data));
+}
+
+static void ril_ussd_notify(GRilIoChannel *io, guint code,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_ussd *ud = user_data;
+	GRilIoParser rilp;
+	char *ussd_from_network = NULL;
+	char *type = NULL;
+	int ussdtype = 0;
+
+	ofono_info("ussd_received");
+
+	GASSERT(code == RIL_UNSOL_ON_USSD);
+	grilio_parser_init(&rilp, data, len);
+	grilio_parser_get_uint32(&rilp, NULL);
+	type = grilio_parser_get_utf8(&rilp);
+	ussd_from_network = grilio_parser_get_utf8(&rilp);
+
+	ussdtype = g_ascii_xdigit_value(*type);
+
+	if (ussd_from_network) {
+		const int data_len = strlen(ussd_from_network);
+		DBG("ussd_received, length %d", data_len);
+		ofono_ussd_notify(ud->ussd, ussdtype, 0xFF,
+			(const unsigned char *) ussd_from_network, data_len);
+	} else {
+		ofono_ussd_notify(ud->ussd, ussdtype, 0, NULL, 0);
+	}
+
+	/* ussd_from_network not freed because core does that if dcs is 0xFF */
+	g_free(type);
+	return;
+}
+
+static gboolean ril_ussd_register(gpointer user_data)
+{
+	struct ril_ussd *ud = user_data;
+
+	DBG("");
+	GASSERT(ud->timer_id);
+	ud->timer_id = 0;
+	ofono_ussd_register(ud->ussd);
+
+	/* Register for USSD events */
+	ud->event_id = grilio_channel_add_unsol_event_handler(ud->io,
+				ril_ussd_notify, RIL_UNSOL_ON_USSD, ud);
+
+	/* Single-shot */
+	return FALSE;
+}
+
+static int ril_ussd_probe(struct ofono_ussd *ussd, unsigned int vendor,
+								void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_ussd *ud = g_try_new0(struct ril_ussd, 1);
+
+	DBG("");
+	ud->ussd = ussd;
+	ud->io = grilio_channel_ref(ril_modem_io(modem));
+	ud->q = grilio_queue_new(ud->io);
+	ud->timer_id = g_idle_add(ril_ussd_register, ud);
+	ofono_ussd_set_data(ussd, ud);
+	return 0;
+}
+
+static void ril_ussd_remove(struct ofono_ussd *ussd)
+{
+	struct ril_ussd *ud = ril_ussd_get_data(ussd);
+
+	DBG("");
+	ofono_ussd_set_data(ussd, NULL);
+
+	if (ud->timer_id > 0) {
+		g_source_remove(ud->timer_id);
+	}
+
+	grilio_channel_remove_handler(ud->io, ud->event_id);
+	grilio_channel_unref(ud->io);
+	grilio_queue_cancel_all(ud->q, FALSE);
+	grilio_queue_unref(ud->q);
+	g_free(ud);
+}
+
+const struct ofono_ussd_driver ril_ussd_driver = {
+	.name           = RILMODEM_DRIVER,
+	.probe          = ril_ussd_probe,
+	.remove         = ril_ussd_remove,
+	.request        = ril_ussd_request,
+	.cancel         = ril_ussd_cancel
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_util.c

@@ -0,0 +1,399 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_util.h"
+#include "ril_log.h"
+
+#include <grilio_channel.h>
+
+#include <sys/socket.h>
+#include <ctype.h>
+
+#include "common.h"
+#include "netreg.h"
+
+const char *ril_error_to_string(int error)
+{
+#define RIL_E_(name) case RIL_E_##name: return #name
+#define GRILIO_E_(name) case GRILIO_STATUS_##name: return "GRILIO_" #name
+	static char unknown[12];
+	switch (error) {
+	case RIL_E_SUCCESS: return "OK";
+	GRILIO_E_(TIMEOUT);
+	GRILIO_E_(CANCELLED);
+	RIL_E_(RADIO_NOT_AVAILABLE);
+	RIL_E_(GENERIC_FAILURE);
+	RIL_E_(PASSWORD_INCORRECT);
+	RIL_E_(SIM_PIN2);
+	RIL_E_(SIM_PUK2);
+	RIL_E_(REQUEST_NOT_SUPPORTED);
+	RIL_E_(CANCELLED);
+	RIL_E_(OP_NOT_ALLOWED_DURING_VOICE_CALL);
+	RIL_E_(OP_NOT_ALLOWED_BEFORE_REG_TO_NW);
+	RIL_E_(SMS_SEND_FAIL_RETRY);
+	RIL_E_(SIM_ABSENT);
+	RIL_E_(SUBSCRIPTION_NOT_AVAILABLE);
+	RIL_E_(MODE_NOT_SUPPORTED);
+	RIL_E_(FDN_CHECK_FAILURE);
+	RIL_E_(ILLEGAL_SIM_OR_ME);
+	RIL_E_(UNUSED);
+	RIL_E_(DIAL_MODIFIED_TO_USSD);
+	RIL_E_(DIAL_MODIFIED_TO_SS);
+	RIL_E_(DIAL_MODIFIED_TO_DIAL);
+	RIL_E_(USSD_MODIFIED_TO_DIAL);
+	RIL_E_(USSD_MODIFIED_TO_SS);
+	RIL_E_(USSD_MODIFIED_TO_USSD);
+	RIL_E_(SS_MODIFIED_TO_DIAL);
+	RIL_E_(SS_MODIFIED_TO_USSD);
+	RIL_E_(SS_MODIFIED_TO_SS);
+	RIL_E_(SUBSCRIPTION_NOT_SUPPORTED);
+	RIL_E_(MISSING_RESOURCE);
+	RIL_E_(NO_SUCH_ELEMENT);
+	RIL_E_(INVALID_PARAMETER);
+	default:
+		snprintf(unknown, sizeof(unknown), "%d", error);
+		return unknown;
+	}
+}
+
+const char *ril_request_to_string(guint request)
+{
+#define RIL_REQUEST_(name) case RIL_REQUEST_##name: return #name
+	static char unknown[24];
+	switch (request) {
+	RIL_REQUEST_(GET_SIM_STATUS);
+	RIL_REQUEST_(ENTER_SIM_PIN);
+	RIL_REQUEST_(ENTER_SIM_PUK);
+	RIL_REQUEST_(ENTER_SIM_PIN2);
+	RIL_REQUEST_(ENTER_SIM_PUK2);
+	RIL_REQUEST_(CHANGE_SIM_PIN);
+	RIL_REQUEST_(CHANGE_SIM_PIN2);
+	RIL_REQUEST_(ENTER_NETWORK_DEPERSONALIZATION);
+	RIL_REQUEST_(GET_CURRENT_CALLS);
+	RIL_REQUEST_(DIAL);
+	RIL_REQUEST_(GET_IMSI);
+	RIL_REQUEST_(HANGUP);
+	RIL_REQUEST_(HANGUP_WAITING_OR_BACKGROUND);
+	RIL_REQUEST_(HANGUP_FOREGROUND_RESUME_BACKGROUND);
+	RIL_REQUEST_(SWITCH_HOLDING_AND_ACTIVE);
+	RIL_REQUEST_(CONFERENCE);
+	RIL_REQUEST_(UDUB);
+	RIL_REQUEST_(LAST_CALL_FAIL_CAUSE);
+	RIL_REQUEST_(SIGNAL_STRENGTH);
+	RIL_REQUEST_(VOICE_REGISTRATION_STATE);
+	RIL_REQUEST_(DATA_REGISTRATION_STATE);
+	RIL_REQUEST_(OPERATOR);
+	RIL_REQUEST_(RADIO_POWER);
+	RIL_REQUEST_(DTMF);
+	RIL_REQUEST_(SEND_SMS);
+	RIL_REQUEST_(SEND_SMS_EXPECT_MORE);
+	RIL_REQUEST_(SETUP_DATA_CALL);
+	RIL_REQUEST_(SIM_IO);
+	RIL_REQUEST_(SEND_USSD);
+	RIL_REQUEST_(CANCEL_USSD);
+	RIL_REQUEST_(GET_CLIR);
+	RIL_REQUEST_(SET_CLIR);
+	RIL_REQUEST_(QUERY_CALL_FORWARD_STATUS);
+	RIL_REQUEST_(SET_CALL_FORWARD);
+	RIL_REQUEST_(QUERY_CALL_WAITING);
+	RIL_REQUEST_(SET_CALL_WAITING);
+	RIL_REQUEST_(SMS_ACKNOWLEDGE);
+	RIL_REQUEST_(GET_IMEI);
+	RIL_REQUEST_(GET_IMEISV);
+	RIL_REQUEST_(ANSWER);
+	RIL_REQUEST_(DEACTIVATE_DATA_CALL);
+	RIL_REQUEST_(QUERY_FACILITY_LOCK);
+	RIL_REQUEST_(SET_FACILITY_LOCK);
+	RIL_REQUEST_(CHANGE_BARRING_PASSWORD);
+	RIL_REQUEST_(QUERY_NETWORK_SELECTION_MODE);
+	RIL_REQUEST_(SET_NETWORK_SELECTION_AUTOMATIC);
+	RIL_REQUEST_(SET_NETWORK_SELECTION_MANUAL);
+	RIL_REQUEST_(QUERY_AVAILABLE_NETWORKS);
+	RIL_REQUEST_(DTMF_START);
+	RIL_REQUEST_(DTMF_STOP);
+	RIL_REQUEST_(BASEBAND_VERSION);
+	RIL_REQUEST_(SEPARATE_CONNECTION);
+	RIL_REQUEST_(SET_MUTE);
+	RIL_REQUEST_(GET_MUTE);
+	RIL_REQUEST_(QUERY_CLIP);
+	RIL_REQUEST_(LAST_DATA_CALL_FAIL_CAUSE);
+	RIL_REQUEST_(DATA_CALL_LIST);
+	RIL_REQUEST_(RESET_RADIO);
+	RIL_REQUEST_(OEM_HOOK_RAW);
+	RIL_REQUEST_(OEM_HOOK_STRINGS);
+	RIL_REQUEST_(SCREEN_STATE);
+	RIL_REQUEST_(SET_SUPP_SVC_NOTIFICATION);
+	RIL_REQUEST_(WRITE_SMS_TO_SIM);
+	RIL_REQUEST_(DELETE_SMS_ON_SIM);
+	RIL_REQUEST_(SET_BAND_MODE);
+	RIL_REQUEST_(QUERY_AVAILABLE_BAND_MODE);
+	RIL_REQUEST_(STK_GET_PROFILE);
+	RIL_REQUEST_(STK_SET_PROFILE);
+	RIL_REQUEST_(STK_SEND_ENVELOPE_COMMAND);
+	RIL_REQUEST_(STK_SEND_TERMINAL_RESPONSE);
+	RIL_REQUEST_(STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM);
+	RIL_REQUEST_(EXPLICIT_CALL_TRANSFER);
+	RIL_REQUEST_(SET_PREFERRED_NETWORK_TYPE);
+	RIL_REQUEST_(GET_PREFERRED_NETWORK_TYPE);
+	RIL_REQUEST_(GET_NEIGHBORING_CELL_IDS);
+	RIL_REQUEST_(SET_LOCATION_UPDATES);
+	RIL_REQUEST_(CDMA_SET_SUBSCRIPTION_SOURCE);
+	RIL_REQUEST_(CDMA_SET_ROAMING_PREFERENCE);
+	RIL_REQUEST_(CDMA_QUERY_ROAMING_PREFERENCE);
+	RIL_REQUEST_(SET_TTY_MODE);
+	RIL_REQUEST_(QUERY_TTY_MODE);
+	RIL_REQUEST_(CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE);
+	RIL_REQUEST_(CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE);
+	RIL_REQUEST_(CDMA_FLASH);
+	RIL_REQUEST_(CDMA_BURST_DTMF);
+	RIL_REQUEST_(CDMA_VALIDATE_AND_WRITE_AKEY);
+	RIL_REQUEST_(CDMA_SEND_SMS);
+	RIL_REQUEST_(CDMA_SMS_ACKNOWLEDGE);
+	RIL_REQUEST_(GSM_GET_BROADCAST_SMS_CONFIG);
+	RIL_REQUEST_(GSM_SET_BROADCAST_SMS_CONFIG);
+	RIL_REQUEST_(GSM_SMS_BROADCAST_ACTIVATION);
+	RIL_REQUEST_(CDMA_GET_BROADCAST_SMS_CONFIG);
+	RIL_REQUEST_(CDMA_SET_BROADCAST_SMS_CONFIG);
+	RIL_REQUEST_(CDMA_SMS_BROADCAST_ACTIVATION);
+	RIL_REQUEST_(CDMA_SUBSCRIPTION);
+	RIL_REQUEST_(CDMA_WRITE_SMS_TO_RUIM);
+	RIL_REQUEST_(CDMA_DELETE_SMS_ON_RUIM);
+	RIL_REQUEST_(DEVICE_IDENTITY);
+	RIL_REQUEST_(EXIT_EMERGENCY_CALLBACK_MODE);
+	RIL_REQUEST_(GET_SMSC_ADDRESS);
+	RIL_REQUEST_(SET_SMSC_ADDRESS);
+	RIL_REQUEST_(REPORT_SMS_MEMORY_STATUS);
+	RIL_REQUEST_(REPORT_STK_SERVICE_IS_RUNNING);
+	RIL_REQUEST_(CDMA_GET_SUBSCRIPTION_SOURCE);
+	RIL_REQUEST_(ISIM_AUTHENTICATION);
+	RIL_REQUEST_(ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU);
+	RIL_REQUEST_(STK_SEND_ENVELOPE_WITH_STATUS);
+	RIL_REQUEST_(VOICE_RADIO_TECH);
+	RIL_REQUEST_(GET_CELL_INFO_LIST);
+	RIL_REQUEST_(SET_UNSOL_CELL_INFO_LIST_RATE);
+	RIL_REQUEST_(SET_INITIAL_ATTACH_APN);
+	RIL_REQUEST_(IMS_REGISTRATION_STATE);
+	RIL_REQUEST_(IMS_SEND_SMS);
+	RIL_REQUEST_(SIM_TRANSMIT_APDU_BASIC);
+	RIL_REQUEST_(SIM_OPEN_CHANNEL);
+	RIL_REQUEST_(SIM_CLOSE_CHANNEL);
+	RIL_REQUEST_(SIM_TRANSMIT_APDU_CHANNEL);
+	RIL_REQUEST_(NV_READ_ITEM);
+	RIL_REQUEST_(NV_WRITE_ITEM);
+	RIL_REQUEST_(NV_WRITE_CDMA_PRL);
+	RIL_REQUEST_(NV_RESET_CONFIG);
+	RIL_REQUEST_(SET_UICC_SUBSCRIPTION);
+	RIL_REQUEST_(ALLOW_DATA);
+	RIL_REQUEST_(GET_HARDWARE_CONFIG);
+	RIL_REQUEST_(SIM_AUTHENTICATION);
+	RIL_REQUEST_(GET_DC_RT_INFO);
+	RIL_REQUEST_(SET_DC_RT_INFO_RATE);
+	RIL_REQUEST_(SET_DATA_PROFILE);
+	RIL_REQUEST_(SHUTDOWN);
+	RIL_REQUEST_(GET_RADIO_CAPABILITY);
+	RIL_REQUEST_(SET_RADIO_CAPABILITY);
+	default:
+		snprintf(unknown, sizeof(unknown), "RIL_REQUEST_%d", request);
+		return unknown;
+	}
+}
+
+const char *ril_unsol_event_to_string(guint event)
+{
+#define RIL_UNSOL_(name) case RIL_UNSOL_##name: return #name
+	static char unknown[24];
+	switch (event) {
+	RIL_UNSOL_(RESPONSE_RADIO_STATE_CHANGED);
+	RIL_UNSOL_(RESPONSE_CALL_STATE_CHANGED);
+	RIL_UNSOL_(RESPONSE_VOICE_NETWORK_STATE_CHANGED);
+	RIL_UNSOL_(RESPONSE_NEW_SMS);
+	RIL_UNSOL_(RESPONSE_NEW_SMS_STATUS_REPORT);
+	RIL_UNSOL_(RESPONSE_NEW_SMS_ON_SIM);
+	RIL_UNSOL_(ON_USSD);
+	RIL_UNSOL_(ON_USSD_REQUEST);
+	RIL_UNSOL_(NITZ_TIME_RECEIVED);
+	RIL_UNSOL_(SIGNAL_STRENGTH);
+	RIL_UNSOL_(DATA_CALL_LIST_CHANGED);
+	RIL_UNSOL_(SUPP_SVC_NOTIFICATION);
+	RIL_UNSOL_(STK_SESSION_END);
+	RIL_UNSOL_(STK_PROACTIVE_COMMAND);
+	RIL_UNSOL_(STK_EVENT_NOTIFY);
+	RIL_UNSOL_(STK_CALL_SETUP);
+	RIL_UNSOL_(SIM_SMS_STORAGE_FULL);
+	RIL_UNSOL_(SIM_REFRESH);
+	RIL_UNSOL_(CALL_RING);
+	RIL_UNSOL_(RESPONSE_SIM_STATUS_CHANGED);
+	RIL_UNSOL_(RESPONSE_CDMA_NEW_SMS);
+	RIL_UNSOL_(RESPONSE_NEW_BROADCAST_SMS);
+	RIL_UNSOL_(CDMA_RUIM_SMS_STORAGE_FULL);
+	RIL_UNSOL_(RESTRICTED_STATE_CHANGED);
+	RIL_UNSOL_(ENTER_EMERGENCY_CALLBACK_MODE);
+	RIL_UNSOL_(CDMA_CALL_WAITING);
+	RIL_UNSOL_(CDMA_OTA_PROVISION_STATUS);
+	RIL_UNSOL_(CDMA_INFO_REC);
+	RIL_UNSOL_(OEM_HOOK_RAW);
+	RIL_UNSOL_(RINGBACK_TONE);
+	RIL_UNSOL_(RESEND_INCALL_MUTE);
+	RIL_UNSOL_(CDMA_SUBSCRIPTION_SOURCE_CHANGED);
+	RIL_UNSOL_(CDMA_PRL_CHANGED);
+	RIL_UNSOL_(EXIT_EMERGENCY_CALLBACK_MODE);
+	RIL_UNSOL_(RIL_CONNECTED);
+	RIL_UNSOL_(VOICE_RADIO_TECH_CHANGED);
+	RIL_UNSOL_(CELL_INFO_LIST);
+	RIL_UNSOL_(RESPONSE_IMS_NETWORK_STATE_CHANGED);
+	RIL_UNSOL_(UICC_SUBSCRIPTION_STATUS_CHANGED);
+	RIL_UNSOL_(SRVCC_STATE_NOTIFY);
+	RIL_UNSOL_(HARDWARE_CONFIG_CHANGED);
+	RIL_UNSOL_(DC_RT_INFO_CHANGED);
+	RIL_UNSOL_(RADIO_CAPABILITY);
+	RIL_UNSOL_(ON_SS);
+	RIL_UNSOL_(STK_CC_ALPHA_NOTIFY);
+	default:
+		snprintf(unknown, sizeof(unknown), "RIL_UNSOL_%d", event);
+		return unknown;
+	}
+}
+
+const char *ril_radio_state_to_string(int radio_state)
+{
+#define RADIO_STATE_(name) case RADIO_STATE_##name: return #name
+	static char unknown[16];
+	switch (radio_state) {
+	RADIO_STATE_(OFF);
+	RADIO_STATE_(UNAVAILABLE);
+	RADIO_STATE_(SIM_NOT_READY);
+	RADIO_STATE_(SIM_LOCKED_OR_ABSENT);
+	RADIO_STATE_(SIM_READY);
+	RADIO_STATE_(RUIM_NOT_READY);
+	RADIO_STATE_(RUIM_READY);
+	RADIO_STATE_(RUIM_LOCKED_OR_ABSENT);
+	RADIO_STATE_(NV_NOT_READY);
+	RADIO_STATE_(NV_READY);
+	RADIO_STATE_(ON);
+	default:
+		snprintf(unknown, sizeof(unknown), "%d (?)", radio_state);
+		return unknown;
+	}
+}
+
+int ril_address_family(const char *addr)
+{
+	if (strchr(addr, ':')) {
+		return AF_INET6;
+	} else if (strchr(addr, '.')) {
+		return AF_INET;
+	} else {
+		return AF_UNSPEC;
+	}
+}
+
+/* Returns enum access_technology or -1 on failure. */
+int ril_parse_tech(const char *stech, int *ril_tech)
+{
+	int access_tech = -1;
+	int tech = -1;
+	if (stech && stech[0]) {
+		tech = atoi(stech);
+		switch (tech) {
+		case RADIO_TECH_GPRS:
+		case RADIO_TECH_GSM:
+			access_tech = ACCESS_TECHNOLOGY_GSM;
+			break;
+		case RADIO_TECH_EDGE:
+			access_tech = ACCESS_TECHNOLOGY_GSM_EGPRS;
+			break;
+		case RADIO_TECH_UMTS:
+			access_tech = ACCESS_TECHNOLOGY_UTRAN;
+			break;
+		case RADIO_TECH_HSDPA:
+			access_tech = ACCESS_TECHNOLOGY_UTRAN_HSDPA;
+			break;
+		case RADIO_TECH_HSUPA:
+			access_tech = ACCESS_TECHNOLOGY_UTRAN_HSUPA;
+			break;
+		case RADIO_TECH_HSPA:
+		case RADIO_TECH_HSPAP:
+			access_tech = ACCESS_TECHNOLOGY_UTRAN_HSDPA_HSUPA;
+			break;
+		case RADIO_TECH_LTE:
+			access_tech = ACCESS_TECHNOLOGY_EUTRAN;
+			break;
+		default:
+			DBG("Unknown RIL tech %s", stech);
+			/* no break */
+		case RADIO_TECH_IWLAN:
+		case RADIO_TECH_UNKNOWN:
+			tech = -1;
+			break;
+		}
+
+	}
+	if (ril_tech) {
+		*ril_tech = tech;
+	}
+	return access_tech;
+}
+
+gboolean ril_parse_mcc_mnc(const char *str, struct ofono_network_operator *op)
+{
+	if (str) {
+		int i;
+		const char *ptr = str;
+
+		/* Three digit country code */
+		for (i = 0;
+		     i < OFONO_MAX_MCC_LENGTH && *ptr && isdigit(*ptr);
+		     i++) {
+			op->mcc[i] = *ptr++;
+		}
+		op->mcc[i] = 0;
+
+		if (i == OFONO_MAX_MCC_LENGTH) {
+			/* Usually 2 but sometimes 3 digit network code */
+			for (i=0;
+			     i<OFONO_MAX_MNC_LENGTH && *ptr && isdigit(*ptr);
+			     i++) {
+				op->mnc[i] = *ptr++;
+			}
+			op->mnc[i] = 0;
+
+			if (i > 0) {
+
+				/*
+				 * Sometimes MCC/MNC are followed by + and
+				 * what looks like the technology code. This
+				 * is of course completely undocumented.
+				 */
+				if (*ptr == '+') {
+					int tech = ril_parse_tech(ptr+1, NULL);
+					if (tech >= 0) {
+						op->tech = tech;
+					}
+				}
+
+				return TRUE;
+			}
+		}
+	}
+	return FALSE;
+}
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_util.h

@@ -0,0 +1,47 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#ifndef RIL_UTIL_H
+#define RIL_UTIL_H
+
+#include "ril_types.h"
+
+struct ofono_network_operator;
+
+const char *ril_error_to_string(int error);
+const char *ril_request_to_string(guint request);
+const char *ril_unsol_event_to_string(guint event);
+const char *ril_radio_state_to_string(int radio_state);
+int ril_parse_tech(const char *stech, int *ril_tech);
+int ril_address_family(const char *addr);
+gboolean ril_parse_mcc_mnc(const char *str, struct ofono_network_operator *op);
+
+#define ril_error_init_ok(err) \
+	((err)->error = 0, (err)->type = OFONO_ERROR_TYPE_NO_ERROR)
+#define ril_error_init_failure(err) \
+	((err)->error = 0, (err)->type = OFONO_ERROR_TYPE_FAILURE)
+
+#define ril_error_ok(err) (ril_error_init_ok(err), err)
+#define ril_error_failure(err) (ril_error_init_failure(err), err)
+
+#endif /* RIL_UTIL_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/ril/ril_voicecall.c

@@ -0,0 +1,865 @@
+/*
+ *  oFono - Open Source Telephony - RIL-based devices
+ *
+ *  Copyright (C) 2015-2016 Jolla 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.
+ */
+
+#include "ril_plugin.h"
+#include "ril_constants.h"
+#include "ril_util.h"
+#include "ril_log.h"
+
+#include "common.h"
+
+/* Amount of ms we wait between CLCC calls */
+#define FLAG_NEED_CLIP 1
+#define MAX_DTMF_BUFFER 32
+
+enum ril_voicecall_events {
+	VOICECALL_EVENT_CALL_STATE_CHANGED,
+	VOICECALL_EVENT_SUPP_SVC_NOTIFICATION,
+	VOICECALL_EVENT_RINGBACK_TONE,
+	VOICECALL_EVENT_COUNT,
+};
+
+struct ril_voicecall {
+	GSList *calls;
+	GRilIoChannel *io;
+	GRilIoQueue *q;
+	struct ofono_voicecall *vc;
+	unsigned int local_release;
+	unsigned char flags;
+	ofono_voicecall_cb_t cb;
+	void *data;
+	guint timer_id;
+	gchar *tone_queue;
+	guint send_dtmf_id;
+	guint clcc_poll_id;
+	gulong event_id[VOICECALL_EVENT_COUNT];
+	gulong supp_svc_notification_id;
+	gulong ringback_tone_event_id;
+};
+
+struct release_id_req {
+	struct ofono_voicecall *vc;
+	ofono_voicecall_cb_t cb;
+	gpointer data;
+	int id;
+};
+
+struct ril_voicecall_change_state_req {
+	struct ofono_voicecall *vc;
+	ofono_voicecall_cb_t cb;
+	gpointer data;
+	int affected_types;
+};
+
+struct lastcause_req {
+	struct ofono_voicecall *vc;
+	int id;
+};
+
+struct ril_voicecall_req {
+	struct ofono_voicecall *vc;
+	ofono_voicecall_cb_t cb;
+	gpointer data;
+};
+
+static void ril_voicecall_send_one_dtmf(struct ril_voicecall *vd);
+static void ril_voicecall_clear_dtmf_queue(struct ril_voicecall *vd);
+
+/*
+ * structs ofono_voicecall and voicecall are fully defined
+ * in src/voicecall.c; we need (read) access to the
+ * call objects, so partially redefine them here.
+ */
+struct ofono_voicecall {
+	GSList *call_list;
+	/* ... */
+};
+
+struct voicecall {
+	struct ofono_call *call;
+	/* ... */
+};
+
+static inline struct ril_voicecall *ril_voicecall_get_data(
+						struct ofono_voicecall *vc)
+{
+	return ofono_voicecall_get_data(vc);
+}
+
+static gint ril_voicecall_compare(gconstpointer a, gconstpointer b)
+{
+	const struct ofono_call *ca = a;
+	const struct ofono_call *cb = b;
+
+	if (ca->id < cb->id)
+		return -1;
+
+	if (ca->id > cb->id)
+		return 1;
+
+	return 0;
+}
+
+static GSList *ril_voicecall_parse_clcc(const void *data, guint len)
+{
+	GRilIoParser rilp;
+	GSList *l = NULL;
+	int num = 0, i;
+	gchar *number, *name;
+
+	grilio_parser_init(&rilp, data, len);
+
+	/* Number of RIL_Call structs */
+	
+	grilio_parser_get_int32(&rilp, &num);
+	for (i = 0; i < num; i++) {
+		struct ofono_call *call = g_new(struct ofono_call, 1);
+		gint tmp;
+
+		ofono_call_init(call);
+		grilio_parser_get_int32(&rilp, &call->status);
+		grilio_parser_get_uint32(&rilp, &call->id);
+		grilio_parser_get_int32(&rilp, &call->phone_number.type);
+		grilio_parser_get_int32(&rilp, NULL); /* isMpty */
+
+		tmp = 0;
+		grilio_parser_get_int32(&rilp, &tmp);
+		call->direction = (tmp ?              /* isMT */
+			CALL_DIRECTION_MOBILE_TERMINATED :
+			CALL_DIRECTION_MOBILE_ORIGINATED);
+
+		grilio_parser_get_int32(&rilp, NULL); /* als */
+		grilio_parser_get_int32(&rilp, &call->type); /* isVoice */
+		grilio_parser_get_int32(&rilp, NULL); /* isVoicePrivacy */
+		number = grilio_parser_get_utf8(&rilp);
+		if (number) {
+			strncpy(call->phone_number.number, number,
+				OFONO_MAX_PHONE_NUMBER_LENGTH);
+			g_free(number);
+		}
+		grilio_parser_get_int32(&rilp, NULL); /* numberPresentation */
+		name = grilio_parser_get_utf8(&rilp);
+		if (name) {
+			strncpy(call->name, name, OFONO_MAX_CALLER_NAME_LENGTH);
+			g_free(name);
+		}
+		grilio_parser_get_int32(&rilp, NULL); /* namePresentation */
+		grilio_parser_get_int32(&rilp, &tmp); /* uusInfo */
+		GASSERT(!tmp);
+
+		if (strlen(call->phone_number.number) > 0) {
+			call->clip_validity = 0;
+		} else {
+			call->clip_validity = 2;
+		}
+
+		DBG("[id=%d,status=%d,type=%d,number=%s,name=%s]",
+				call->id, call->status, call->type,
+				call->phone_number.number, call->name);
+
+		l = g_slist_insert_sorted(l, call, ril_voicecall_compare);
+	}
+
+	return l;
+}
+
+/* Valid call statuses have value >= 0 */
+static int call_status_with_id(struct ofono_voicecall *vc, int id)
+{
+	GSList *l;
+	struct voicecall *v;
+
+	GASSERT(vc);
+
+	for (l = vc->call_list; l; l = l->next) {
+		v = l->data;
+		if (v->call->id == id) {
+			return v->call->status;
+		}
+	}
+
+	return -1;
+}
+
+static void ril_voicecall_lastcause_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct lastcause_req *reqdata = user_data;
+	struct ofono_voicecall *vc = reqdata->vc;
+	int tmp;
+	int id = reqdata->id;
+	int call_status;
+
+	enum ofono_disconnect_reason reason = OFONO_DISCONNECT_REASON_ERROR;
+	int last_cause = CALL_FAIL_ERROR_UNSPECIFIED;
+	GRilIoParser rilp;
+	grilio_parser_init(&rilp, data, len);
+	if (grilio_parser_get_int32(&rilp, &tmp) && tmp > 0) {
+		grilio_parser_get_int32(&rilp, &last_cause);
+	}
+
+	/*
+	 * Not all call control cause values specified in 3GPP TS 24.008
+	 * "Mobile radio interface Layer 3 specification; Core network
+	 * protocols", Annex H, are properly reflected in the RIL API.
+	 * For example, cause #21 "call rejected" is mapped to
+	 * CALL_FAIL_ERROR_UNSPECIFIED, and thus indistinguishable
+	 * from a network failure.
+	 */
+	switch (last_cause) {
+		case CALL_FAIL_UNOBTAINABLE_NUMBER:
+		case CALL_FAIL_NORMAL:
+		case CALL_FAIL_BUSY:
+		case CALL_FAIL_NO_ROUTE_TO_DESTINATION:
+		case CALL_FAIL_CHANNEL_UNACCEPTABLE:
+		case CALL_FAIL_OPERATOR_DETERMINED_BARRING:
+		case CALL_FAIL_NO_USER_RESPONDING:
+		case CALL_FAIL_USER_ALERTING_NO_ANSWER:
+		case CALL_FAIL_CALL_REJECTED:
+		case CALL_FAIL_NUMBER_CHANGED:
+		case CALL_FAIL_ANONYMOUS_CALL_REJECTION:
+		case CALL_FAIL_PRE_EMPTION:
+		case CALL_FAIL_DESTINATION_OUT_OF_ORDER:
+		case CALL_FAIL_INCOMPLETE_NUMBER:
+		case CALL_FAIL_FACILITY_REJECTED:
+			reason = OFONO_DISCONNECT_REASON_REMOTE_HANGUP;
+			break;
+
+		case CALL_FAIL_NORMAL_UNSPECIFIED:
+			call_status = call_status_with_id(vc, id);
+			if (call_status == CALL_STATUS_ACTIVE ||
+			    call_status == CALL_STATUS_HELD ||
+			    call_status == CALL_STATUS_DIALING ||
+			    call_status == CALL_STATUS_ALERTING) {
+				reason = OFONO_DISCONNECT_REASON_REMOTE_HANGUP;
+			} else if (call_status == CALL_STATUS_INCOMING) {
+				reason = OFONO_DISCONNECT_REASON_LOCAL_HANGUP;
+			}
+			break;
+
+		case CALL_FAIL_ERROR_UNSPECIFIED:
+			call_status = call_status_with_id(vc, id);
+			if (call_status == CALL_STATUS_DIALING ||
+			    call_status == CALL_STATUS_ALERTING) {
+				reason = OFONO_DISCONNECT_REASON_REMOTE_HANGUP;
+			}
+			break;
+
+		default:
+			reason = OFONO_DISCONNECT_REASON_ERROR;
+			break;
+	}
+
+	ofono_info("Call %d ended with RIL cause %d -> ofono reason %d",
+						id, last_cause, reason);
+
+	ofono_voicecall_disconnected(vc, id, reason, NULL);
+}
+
+static void ril_voicecall_clcc_poll_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_voicecall *vd = user_data;
+	GSList *calls;
+	GSList *n, *o;
+	struct ofono_error error;
+
+	GASSERT(vd->clcc_poll_id);
+	vd->clcc_poll_id = 0;
+
+	if (status != RIL_E_SUCCESS) {
+		ofono_error("We are polling CLCC and received an error");
+		ofono_error("All bets are off for call management");
+		return;
+	}
+
+	calls = ril_voicecall_parse_clcc(data, len);
+
+	n = calls;
+	o = vd->calls;
+
+	while (n || o) {
+		struct ofono_call *nc = n ? n->data : NULL;
+		struct ofono_call *oc = o ? o->data : NULL;
+
+		if (oc && (nc == NULL || (nc->id > oc->id))) {
+			if (vd->local_release & (1 << oc->id)) {
+				ofono_voicecall_disconnected(vd->vc, oc->id,
+					OFONO_DISCONNECT_REASON_LOCAL_HANGUP,
+					NULL);
+			} else {
+				/* Get disconnect cause before informing
+				 * oFono core */
+				struct lastcause_req *reqdata =
+					g_new0(struct lastcause_req, 1);
+
+				reqdata->vc = vd->vc;
+				reqdata->id = oc->id;
+				grilio_queue_send_request_full(vd->q, NULL,
+					RIL_REQUEST_LAST_CALL_FAIL_CAUSE,
+					ril_voicecall_lastcause_cb,
+					g_free, reqdata);
+			}
+
+			ril_voicecall_clear_dtmf_queue(vd);
+			o = o->next;
+
+		} else if (nc && (oc == NULL || (nc->id < oc->id))) {
+			/* new call, signal it */
+			if (nc->type) {
+				ofono_voicecall_notify(vd->vc, nc);
+				if (vd->cb) {
+					ofono_voicecall_cb_t cb = vd->cb;
+					cb(ril_error_ok(&error), vd->data);
+					vd->cb = NULL;
+					vd->data = NULL;
+				}
+			}
+
+			n = n->next;
+
+		} else {
+			/*
+			 * Always use the clip_validity from old call
+			 * the only place this is truly told to us is
+			 * in the CLIP notify, the rest are fudged
+			 * anyway.  Useful when RING, CLIP is used,
+			 * and we're forced to use CLCC and clip_validity
+			 * is 1
+			 */
+			if (oc->clip_validity == 1) {
+				nc->clip_validity = oc->clip_validity;
+			}
+
+			nc->cnap_validity = oc->cnap_validity;
+
+			/*
+			 * CDIP doesn't arrive as part of CLCC, always
+			 * re-use from the old call
+			 */
+			memcpy(&nc->called_number, &oc->called_number,
+					sizeof(oc->called_number));
+
+			/*
+			 * If the CLIP is not provided and the CLIP never
+			 * arrives, or RING is used, then signal the call
+			 * here
+			 */
+			if (nc->status == CALL_STATUS_INCOMING &&
+					(vd->flags & FLAG_NEED_CLIP)) {
+				if (nc->type) {
+					ofono_voicecall_notify(vd->vc, nc);
+				}
+
+				vd->flags &= ~FLAG_NEED_CLIP;
+			} else if (memcmp(nc, oc, sizeof(*nc)) && nc->type) {
+				ofono_voicecall_notify(vd->vc, nc);
+			}
+
+			n = n->next;
+			o = o->next;
+		}
+	}
+
+	g_slist_free_full(vd->calls, g_free);
+
+	vd->calls = calls;
+	vd->local_release = 0;
+}
+
+static void ril_voicecall_clcc_poll(struct ril_voicecall *vd)
+{
+	GASSERT(vd);
+	if (!vd->clcc_poll_id) {
+		vd->clcc_poll_id = grilio_queue_send_request_full(vd->q,
+					NULL, RIL_REQUEST_GET_CURRENT_CALLS,
+					ril_voicecall_clcc_poll_cb, NULL, vd);
+	}
+}
+
+static void ril_voicecall_request_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_voicecall_change_state_req *req = user_data;
+	struct ril_voicecall *vd = ril_voicecall_get_data(req->vc);
+	struct ofono_error error;
+
+	if (status == RIL_E_SUCCESS) {
+		GSList *l;
+
+		if (req->affected_types) {
+			for (l = vd->calls; l; l = l->next) {
+				struct ofono_call *call = l->data;
+
+				if (req->affected_types & (1 << call->status)) {
+					vd->local_release |= (1 << call->id);
+				}
+			}
+		}
+
+		ril_error_init_ok(&error);
+	} else {
+		ofono_error("generic fail");
+		ril_error_init_failure(&error);
+	}
+
+	ril_voicecall_clcc_poll(vd);
+
+	/* We have to callback after we schedule a poll if required */
+	if (req->cb) {
+		req->cb(&error, req->data);
+	}
+}
+
+static void ril_voicecall_request(const guint rreq, struct ofono_voicecall *vc,
+		unsigned int affected_types, GRilIoRequest *ioreq,
+		ofono_voicecall_cb_t cb, void *data)
+{
+	struct ril_voicecall *vd = ril_voicecall_get_data(vc);
+	struct ril_voicecall_change_state_req *req;
+
+	req = g_new0(struct ril_voicecall_change_state_req, 1);
+	req->vc = vc;
+	req->cb = cb;
+	req->data = data;
+	req->affected_types = affected_types;
+
+	grilio_queue_send_request_full(vd->q, ioreq, rreq,
+				ril_voicecall_request_cb, g_free, req);
+}
+
+static void ril_voicecall_dial_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_voicecall_req *cbd = user_data;
+	struct ofono_voicecall *vc = cbd->vc;
+	struct ril_voicecall *vd = ril_voicecall_get_data(vc);
+
+	if (status == RIL_E_SUCCESS) {
+		if (vd->cb) {
+			/* CLCC will update the oFono call list with
+			 * proper ids if it's not done yet */
+			ril_voicecall_clcc_poll(vd);
+		}
+	} else {
+		struct ofono_error error;
+		ofono_error("call failed.");
+		vd->cb = cbd->cb;
+		vd->data = cbd->data;
+		cbd->cb(ril_error_failure(&error), cbd->data);
+	}
+}
+
+static void ril_voicecall_dial(struct ofono_voicecall *vc,
+			const struct ofono_phone_number *ph,
+			enum ofono_clir_option clir, ofono_voicecall_cb_t cb,
+			void *data)
+{
+	struct ril_voicecall *vd = ril_voicecall_get_data(vc);
+	struct ril_voicecall_req *cbd = g_new(struct ril_voicecall_req, 1);
+	const char *phstr =  phone_number_to_string(ph);
+	GRilIoRequest *req = grilio_request_new();
+
+	ofono_info("dialing \"%s\"", phstr);
+
+	DBG("%s,%d,0", phstr, clir);
+	cbd->vc = vc;
+	cbd->cb = cb;
+	cbd->data = data;
+
+	GASSERT(!vd->cb);
+	vd->cb = cbd->cb;
+	vd->data = cbd->data;
+
+	grilio_request_append_utf8(req, phstr); /* Number to dial */
+	grilio_request_append_int32(req, clir); /* CLIR mode */
+	grilio_request_append_int32(req, 0);    /* UUS information (absent) */
+
+	grilio_queue_send_request_full(vd->q, req, RIL_REQUEST_DIAL,
+					ril_voicecall_dial_cb, g_free, cbd);
+	grilio_request_unref(req);
+}
+
+static void ril_voicecall_hangup_all(struct ofono_voicecall *vc,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	struct ril_voicecall *vd = ril_voicecall_get_data(vc);
+	struct ofono_error error;
+	GSList *l;
+
+	for (l = vd->calls; l; l = l->next) {
+		struct ofono_call *call = l->data;
+		GRilIoRequest *req = grilio_request_sized_new(8);
+
+		/* TODO: Hangup just the active ones once we have call
+		 * state tracking (otherwise it can't handle ringing) */
+		DBG("Hanging up call with id %d", call->id);
+		grilio_request_append_int32(req, 1); /* Always 1 - AT+CHLD=1x */
+		grilio_request_append_int32(req, call->id);
+
+		/* Send request to RIL */
+		ril_voicecall_request(RIL_REQUEST_HANGUP, vc, 0x3f, req,
+								NULL, NULL);
+		grilio_request_unref(req);
+	}
+
+	/* TODO: Deal in case of an error at hungup */
+	cb(ril_error_ok(&error), data);
+}
+
+static void ril_voicecall_hangup_specific(struct ofono_voicecall *vc,
+		int id, ofono_voicecall_cb_t cb, void *data)
+{
+	GRilIoRequest *req = grilio_request_sized_new(8);
+	struct ofono_error error;
+
+	DBG("Hanging up call with id %d", id);
+	grilio_request_append_int32(req, 1); /* Always 1 - AT+CHLD=1x */
+	grilio_request_append_int32(req, id);
+
+	/* Send request to RIL */
+	ril_voicecall_request(RIL_REQUEST_HANGUP, vc, 0x3f, req, NULL, NULL);
+	grilio_request_unref(req);
+	cb(ril_error_ok(&error), data);
+}
+
+static void ril_voicecall_call_state_changed_event(GRilIoChannel *io,
+		guint ril_event, const void *data, guint len, void *user_data)
+{
+	struct ril_voicecall *vd = user_data;
+
+	GASSERT(ril_event == RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED);
+
+	/* Just need to request the call list again */
+	ril_voicecall_clcc_poll(vd);
+}
+
+static void ril_voicecall_supp_svc_notification_event(GRilIoChannel *io,
+		guint ril_event, const void *data, guint len, void *user_data)
+{
+	GRilIoParser rilp;
+	struct ril_voicecall *vd = user_data;
+	struct ofono_phone_number phone;
+	int type = 0, code = 0, index = 0;
+	char *tmp = NULL;
+
+	GASSERT(ril_event == RIL_UNSOL_SUPP_SVC_NOTIFICATION);
+
+	grilio_parser_init(&rilp, data, len);
+	grilio_parser_get_int32(&rilp, &type);
+	grilio_parser_get_int32(&rilp, &code);
+	grilio_parser_get_int32(&rilp, &index);
+	grilio_parser_get_int32(&rilp, NULL);
+	tmp = grilio_parser_get_utf8(&rilp);
+
+	if (tmp) {
+		strncpy(phone.number, tmp, OFONO_MAX_PHONE_NUMBER_LENGTH);
+		phone.number[OFONO_MAX_PHONE_NUMBER_LENGTH] = 0;
+		g_free(tmp);
+	} else {
+		phone.number[0] = 0;
+	}
+
+	DBG("RIL data: MT/MO: %i, code: %i, index: %i",  type, code, index);
+
+	/* 0 stands for MO intermediate (support TBD), 1 for MT unsolicited */
+	if (type == 1) {
+		ofono_voicecall_ssn_mt_notify(vd->vc, 0, code, index, &phone);
+	} else {
+		ofono_error("Unknown SS notification");
+	}
+}
+
+static void ril_voicecall_answer(struct ofono_voicecall *vc,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	/* Send request to RIL */
+	DBG("Answering current call");
+	ril_voicecall_request(RIL_REQUEST_ANSWER, vc, 0, NULL, cb, data);
+}
+
+static void ril_voicecall_send_dtmf_cb(GRilIoChannel *io, int status,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_voicecall *vd = user_data;
+
+	GASSERT(vd->send_dtmf_id);
+	vd->send_dtmf_id = 0;
+
+	if (status == RIL_E_SUCCESS) {
+		/* Remove sent DTMF character from queue */
+		gchar *tmp = g_strdup(vd->tone_queue + 1);
+		g_free(vd->tone_queue);
+		vd->tone_queue = tmp;
+
+		/* Send the next one */
+		ril_voicecall_send_one_dtmf(vd);
+	} else {
+		DBG("error=%d", status);
+		ril_voicecall_clear_dtmf_queue(vd);
+	}
+}
+
+static void ril_voicecall_send_one_dtmf(struct ril_voicecall *vd)
+{
+	if (!vd->send_dtmf_id && vd->tone_queue && vd->tone_queue[0]) {
+		GRilIoRequest *req = grilio_request_sized_new(4);
+
+		/* RIL wants just one character */
+		DBG("%c", vd->tone_queue[0]);
+		grilio_request_append_utf8_chars(req, vd->tone_queue, 1);
+		vd->send_dtmf_id = grilio_queue_send_request_full(vd->q, req,
+			RIL_REQUEST_DTMF, ril_voicecall_send_dtmf_cb, NULL, vd);
+		grilio_request_unref(req);
+	}
+}
+
+static void ril_voicecall_send_dtmf(struct ofono_voicecall *vc,
+		const char *dtmf, ofono_voicecall_cb_t cb, void *data)
+{
+	struct ril_voicecall *vd = ril_voicecall_get_data(vc);
+	struct ofono_error error;
+
+	DBG("Queue '%s'",dtmf);
+
+	/*
+	 * Queue any incoming DTMF (up to MAX_DTMF_BUFFER characters),
+	 * send them to RIL one-by-one, immediately call back
+	 * core with no error
+	 */
+	g_strlcat(vd->tone_queue, dtmf, MAX_DTMF_BUFFER);
+	ril_voicecall_send_one_dtmf(vd);
+
+	cb(ril_error_ok(&error), data);
+}
+
+static void ril_voicecall_clear_dtmf_queue(struct ril_voicecall *vd)
+{
+	g_free(vd->tone_queue);
+	vd->tone_queue = g_strnfill(MAX_DTMF_BUFFER + 1, '\0');
+	if (vd->send_dtmf_id) {
+		grilio_channel_cancel_request(vd->io, vd->send_dtmf_id, FALSE);
+		vd->send_dtmf_id = 0;
+	}
+}
+
+static void ril_voicecall_clcc_poll_on_success(GRilIoChannel *io,
+		int status, const void *data, guint len, void *user_data)
+{
+	if (status == RIL_E_SUCCESS) {
+		ril_voicecall_clcc_poll((struct ril_voicecall *)user_data);
+	}
+}
+
+static void ril_voicecall_create_multiparty(struct ofono_voicecall *vc,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	struct ril_voicecall *vd = ril_voicecall_get_data(vc);
+	grilio_queue_send_request_full(vd->q, NULL, RIL_REQUEST_CONFERENCE,
+			ril_voicecall_clcc_poll_on_success, NULL, vd);
+}
+
+static void ril_voicecall_transfer(struct ofono_voicecall *vc,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	ril_voicecall_request(RIL_REQUEST_EXPLICIT_CALL_TRANSFER,
+			vc, 0, NULL, cb, data);
+}
+
+static void ril_voicecall_private_chat(struct ofono_voicecall *vc, int id,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	struct ril_voicecall *vd = ril_voicecall_get_data(vc);
+	GRilIoRequest *req = grilio_request_sized_new(8);
+	grilio_request_append_int32(req, 1);
+	grilio_request_append_int32(req, id);
+	grilio_queue_send_request_full(vd->q, req,
+				RIL_REQUEST_SEPARATE_CONNECTION,
+				ril_voicecall_clcc_poll_on_success, NULL, vd);
+	grilio_request_unref(req);
+}
+
+static void ril_voicecall_swap_without_accept(struct ofono_voicecall *vc,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	ril_voicecall_request(RIL_REQUEST_SWITCH_HOLDING_AND_ACTIVE,
+			vc, 0, NULL, cb, data);
+}
+
+static void ril_voicecall_hold_all_active(struct ofono_voicecall *vc,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	ril_voicecall_request(RIL_REQUEST_SWITCH_HOLDING_AND_ACTIVE,
+			vc, 0, NULL, cb, data);
+}
+
+static void ril_voicecall_release_all_held(struct ofono_voicecall *vc,
+					ofono_voicecall_cb_t cb, void *data)
+{
+	ril_voicecall_request(RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND,
+			vc, 0, NULL, cb, data);
+}
+
+static void ril_voicecall_release_all_active(struct ofono_voicecall *vc,
+					ofono_voicecall_cb_t cb, void *data)
+{
+	ril_voicecall_request(RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND,
+			vc, 0, NULL, cb, data);
+}
+
+static void ril_voicecall_set_udub(struct ofono_voicecall *vc,
+					ofono_voicecall_cb_t cb, void *data)
+{
+	ril_voicecall_request(RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND,
+			vc, 0, NULL, cb, data);
+}
+
+static gboolean ril_voicecall_enable_supp_svc(struct ril_voicecall *vd)
+{
+	GRilIoRequest *req = grilio_request_sized_new(8);
+
+	grilio_request_append_int32(req, 1); /* size of array */
+	grilio_request_append_int32(req, 1); /* notifications enabled */
+
+	grilio_queue_send_request(vd->q, req,
+				RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION);
+	grilio_request_unref(req);
+
+	/* Makes this a single shot */
+	return FALSE;
+}
+
+static void ril_voicecall_ringback_tone_event(GRilIoChannel *io,
+		guint code, const void *data, guint len, void *user_data)
+{
+	struct ril_voicecall *vd = user_data;
+	GRilIoParser rilp;
+	guint32 playTone = FALSE;
+	int tmp;
+
+	GASSERT(code == RIL_UNSOL_RINGBACK_TONE);
+	grilio_parser_init(&rilp, data, len);
+	if (grilio_parser_get_int32(&rilp, &tmp) && tmp > 0) {
+		grilio_parser_get_uint32(&rilp, &playTone);
+	}
+
+	DBG("play ringback tone: %d", playTone);
+	ofono_voicecall_ringback_tone_notify(vd->vc, playTone);
+}
+
+static gboolean ril_delayed_register(gpointer user_data)
+{
+	struct ril_voicecall *vd = user_data;
+
+	GASSERT(vd->timer_id);
+	vd->timer_id = 0;
+	ofono_voicecall_register(vd->vc);
+
+	/* Initialize call list */
+	ril_voicecall_clcc_poll(vd);
+
+	/* request supplementary service notifications*/
+	ril_voicecall_enable_supp_svc(vd);
+
+	/* Unsol when call state changes */
+	vd->event_id[VOICECALL_EVENT_CALL_STATE_CHANGED] =
+		grilio_channel_add_unsol_event_handler(vd->io,
+				ril_voicecall_call_state_changed_event,
+				RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, vd);
+
+	/* Unsol when call set in hold */
+	vd->event_id[VOICECALL_EVENT_SUPP_SVC_NOTIFICATION] =
+		grilio_channel_add_unsol_event_handler(vd->io,
+				ril_voicecall_supp_svc_notification_event,
+				RIL_UNSOL_SUPP_SVC_NOTIFICATION, vd);
+
+	/* Register for ringback tone notifications */
+	vd->event_id[VOICECALL_EVENT_RINGBACK_TONE] =
+		grilio_channel_add_unsol_event_handler(vd->io,
+				ril_voicecall_ringback_tone_event,
+				RIL_UNSOL_RINGBACK_TONE, vd);
+
+	/* This makes the timeout a single-shot */
+	return FALSE;
+}
+
+static int ril_voicecall_probe(struct ofono_voicecall *vc, unsigned int vendor,
+				void *data)
+{
+	struct ril_modem *modem = data;
+	struct ril_voicecall *vd;
+
+	DBG("");
+	vd = g_new0(struct ril_voicecall, 1);
+	vd->io = grilio_channel_ref(ril_modem_io(modem));
+	vd->q = grilio_queue_new(vd->io);
+	vd->vc = vc;
+	vd->timer_id = g_idle_add(ril_delayed_register, vd);
+	ril_voicecall_clear_dtmf_queue(vd);
+	ofono_voicecall_set_data(vc, vd);
+	return 0;
+}
+
+static void ril_voicecall_remove(struct ofono_voicecall *vc)
+{
+	int i;
+	struct ril_voicecall *vd = ril_voicecall_get_data(vc);
+
+	DBG("");
+	ofono_voicecall_set_data(vc, NULL);
+	g_slist_foreach(vd->calls, (GFunc) g_free, NULL);
+	g_slist_free(vd->calls);
+
+	for (i=0; i<G_N_ELEMENTS(vd->event_id); i++) {
+		grilio_channel_remove_handler(vd->io, vd->event_id[i]);
+	}
+
+	if (vd->timer_id > 0) {
+		g_source_remove(vd->timer_id);
+	}
+
+	grilio_channel_unref(vd->io);
+	grilio_queue_cancel_all(vd->q, FALSE);
+	grilio_queue_unref(vd->q);
+	g_free(vd->tone_queue);
+	g_free(vd);
+}
+
+const struct ofono_voicecall_driver ril_voicecall_driver = {
+	.name                   = RILMODEM_DRIVER,
+	.probe                  = ril_voicecall_probe,
+	.remove                 = ril_voicecall_remove,
+	.dial                   = ril_voicecall_dial,
+	.answer                 = ril_voicecall_answer,
+	.hangup_all             = ril_voicecall_hangup_all,
+	.release_specific       = ril_voicecall_hangup_specific,
+	.send_tones             = ril_voicecall_send_dtmf,
+	.create_multiparty      = ril_voicecall_create_multiparty,
+	.transfer               = ril_voicecall_transfer,
+	.private_chat           = ril_voicecall_private_chat,
+	.swap_without_accept    = ril_voicecall_swap_without_accept,
+	.hold_all_active        = ril_voicecall_hold_all_active,
+	.release_all_held       = ril_voicecall_release_all_held,
+	.set_udub               = ril_voicecall_set_udub,
+	.release_all_active     = ril_voicecall_release_all_active
+};
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 8
+ * indent-tabs-mode: t
+ * End:
+ */

ofono/drivers/rilmodem/call-barring.c

@@ -0,0 +1,310 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2014 Jolla Ltd
+ *  Contact: Miia Leinonen
+ *
+ *  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
+ *
+ */
+
+#include <glib.h>
+
+#include <ofono/log.h>
+#include <ofono/modem.h>
+
+#include "common.h"
+#include "gril.h"
+#include "call-barring.h"
+#include "rilmodem.h"
+#include "ril_constants.h"
+
+/* See 3GPP 27.007 7.4 for possible values */
+#define RIL_MAX_SERVICE_LENGTH 3
+
+/*
+ * ril.h does not state that string count must be given, but that is
+ * still expected by the modem
+ */
+#define RIL_QUERY_STRING_COUNT 4
+#define RIL_SET_STRING_COUNT 5
+#define RIL_SET_PW_STRING_COUNT 3
+
+#define RIL_LENGTH_ZERO 0
+
+struct barring_data {
+	GRil *ril;
+	guint timer_id;
+};
+
+static void ril_call_barring_query_cb(struct ril_msg *message,
+					gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	struct parcel rilp;
+	struct ofono_error error;
+	ofono_call_barring_query_cb_t cb = cbd->cb;
+	int bearer_class = 0;
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("Call Barring query failed, err: %i",
+			message->error);
+		decode_ril_error(&error, "FAIL");
+		goto out;
+	}
+
+	ril_util_init_parcel(message, &rilp);
+
+	/*
+	 * Services for which the specified barring facility is active.
+	 * "0" means "disabled for all, -1 if unknown"
+	 */
+	parcel_r_int32(&rilp); /* count - we know there is only 1 */
+	bearer_class = parcel_r_int32(&rilp);
+	DBG("Active services: %i", bearer_class);
+
+	decode_ril_error(&error, "OK");
+
+out:
+	cb(&error, bearer_class, cbd->data);
+}
+
+static void ril_call_barring_query(struct ofono_call_barring *cb,
+					const char *lock, int cls,
+					ofono_call_barring_query_cb_t callback,
+					void *data)
+{
+	struct barring_data *bd = ofono_call_barring_get_data(cb);
+	struct cb_data *cbd = cb_data_new(callback, data);
+	struct parcel rilp;
+	int ret = 0;
+	char cls_textual[RIL_MAX_SERVICE_LENGTH];
+
+	DBG("lock: %s, services to query: %i", lock, cls);
+
+	/*
+	 * RIL modems do not support 7 as default bearer class. According to
+	 * the 22.030 Annex C: When service code is not given it corresponds to
+	 * "All tele and bearer services"
+	 */
+	if (cls == BEARER_CLASS_DEFAULT)
+		cls = SERVICE_CLASS_NONE;
+
+	sprintf(cls_textual, "%d", cls);
+
+	/*
+	 * See 3GPP 27.007 7.4 for parameter descriptions.
+	 * According to ril.h password should be empty string "" when not
+	 * needed, but in reality we only need to give string length as 0
+	 */
+	parcel_init(&rilp);
+	parcel_w_int32(&rilp, RIL_QUERY_STRING_COUNT);	/* Nbr of strings */
+	parcel_w_string(&rilp, (char *) lock);		/* Facility code */
+	parcel_w_int32(&rilp, RIL_LENGTH_ZERO);		/* Password length */
+	parcel_w_string(&rilp, (char *) cls_textual);
+	parcel_w_string(&rilp, NULL); /* AID (for FDN, not yet supported) */
+
+	ret = g_ril_send(bd->ril, RIL_REQUEST_QUERY_FACILITY_LOCK,
+			rilp.data, rilp.size, ril_call_barring_query_cb,
+			cbd, g_free);
+
+	parcel_free(&rilp);
+
+	if (ret <= 0) {
+		ofono_error("Sending Call Barring query failed, err: %i", ret);
+		g_free(cbd);
+		CALLBACK_WITH_FAILURE(callback, -1, data);
+	}
+}
+
+static void ril_call_barring_set_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	struct ofono_error error;
+	ofono_call_barring_set_cb_t cb = cbd->cb;
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("Call Barring Set request failed, err: %i",
+				message->error);
+		decode_ril_error(&error, "FAIL");
+		goto out;
+	}
+
+	decode_ril_error(&error, "OK");
+
+out:
+	cb(&error, cbd->data);
+}
+
+static void ril_call_barring_set(struct ofono_call_barring *cb,
+				const char *lock, int enable,
+				const char *passwd, int cls,
+				ofono_call_barring_set_cb_t callback,
+				void *data)
+{
+	struct barring_data *bd = ofono_call_barring_get_data(cb);
+	struct cb_data *cbd = cb_data_new(callback, data);
+	struct parcel rilp;
+	int ret = 0;
+	char cls_textual[RIL_MAX_SERVICE_LENGTH];
+
+	DBG("lock: %s, enable: %i, bearer class: %i", lock, enable, cls);
+
+	/*
+	 * RIL modem does not support 7 as default bearer class. According to
+	 * the 22.030 Annex C: When service code is not given it corresponds to
+	 * "All tele and bearer services"
+	 */
+	if (cls == BEARER_CLASS_DEFAULT)
+		cls = SERVICE_CLASS_NONE;
+
+	sprintf(cls_textual, "%d", cls);
+
+	/* See 3GPP 27.007 7.4 for parameter descriptions */
+	parcel_init(&rilp);
+	parcel_w_int32(&rilp, RIL_SET_STRING_COUNT);	/* Nbr of strings */
+	parcel_w_string(&rilp, (char *) lock);		/* Facility code */
+
+	if (enable)
+		parcel_w_string(&rilp, RIL_FACILITY_LOCK);
+	else
+		parcel_w_string(&rilp, RIL_FACILITY_UNLOCK);
+
+	parcel_w_string(&rilp, (char *) passwd);
+	parcel_w_string(&rilp, (char *) cls_textual);
+	parcel_w_string(&rilp, NULL);	/* AID (for FDN, not yet supported) */
+
+	ret = g_ril_send(bd->ril, RIL_REQUEST_SET_FACILITY_LOCK,
+			rilp.data, rilp.size, ril_call_barring_set_cb,
+			cbd, g_free);
+
+	parcel_free(&rilp);
+
+	if (ret <= 0) {
+		ofono_error("Sending Call Barring Set request failed, err: %i",
+				ret);
+		g_free(cbd);
+		CALLBACK_WITH_FAILURE(callback, data);
+	}
+}
+
+static void ril_call_barring_set_passwd_cb(struct ril_msg *message,
+						gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	struct ofono_error error;
+	ofono_call_barring_set_cb_t cb = cbd->cb;
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("Call Barring Set PW req failed, err: %i",
+				message->error);
+		decode_ril_error(&error, "FAIL");
+		goto out;
+	}
+
+	decode_ril_error(&error, "OK");
+
+out:
+	cb(&error, cbd->data);
+}
+
+static void ril_call_barring_set_passwd(struct ofono_call_barring *barr,
+					const char *lock,
+					const char *old_passwd,
+					const char *new_passwd,
+					ofono_call_barring_set_cb_t cb,
+					void *data)
+{
+	struct barring_data *bd = ofono_call_barring_get_data(barr);
+	struct cb_data *cbd = cb_data_new(cb, data);
+	struct parcel rilp;
+	int ret = 0;
+
+	DBG("");
+
+	parcel_init(&rilp);
+	parcel_w_int32(&rilp, RIL_SET_PW_STRING_COUNT);	/* Nbr of strings */
+	parcel_w_string(&rilp, (char *) lock);		/* Facility code */
+	parcel_w_string(&rilp, (char *) old_passwd);
+	parcel_w_string(&rilp, (char *) new_passwd);
+
+	ret = g_ril_send(bd->ril, RIL_REQUEST_CHANGE_BARRING_PASSWORD,
+			rilp.data, rilp.size, ril_call_barring_set_passwd_cb,
+			cbd, g_free);
+
+	parcel_free(&rilp);
+
+	if (ret <= 0) {
+		ofono_error("Sending Call Barring Set PW req failed, err: %i",
+				ret);
+		g_free(cbd);
+		CALLBACK_WITH_FAILURE(cb, data);
+	}
+}
+
+static gboolean ril_delayed_register(gpointer user_data)
+{
+	struct ofono_call_barring *cb = user_data;
+	struct barring_data *bd = ofono_call_barring_get_data(cb);
+
+	bd->timer_id = 0;
+
+	ofono_call_barring_register(cb);
+	return FALSE;
+}
+
+static int ril_call_barring_probe(struct ofono_call_barring *cb,
+					unsigned int vendor, void *user)
+{
+	GRil *ril = user;
+	struct barring_data *bd = g_try_new0(struct barring_data, 1);
+
+	bd->ril = g_ril_clone(ril);
+	ofono_call_barring_set_data(cb, bd);
+	bd->timer_id = g_timeout_add_seconds(2, ril_delayed_register, cb);
+
+	return 0;
+}
+
+static void ril_call_barring_remove(struct ofono_call_barring *cb)
+{
+	struct barring_data *data = ofono_call_barring_get_data(cb);
+	ofono_call_barring_set_data(cb, NULL);
+
+	if (data->timer_id > 0)
+		g_source_remove(data->timer_id);
+
+	g_ril_unref(data->ril);
+	g_free(data);
+}
+
+static struct ofono_call_barring_driver driver = {
+	.name			= "rilmodem",
+	.probe			= ril_call_barring_probe,
+	.remove			= ril_call_barring_remove,
+	.query			= ril_call_barring_query,
+	.set			= ril_call_barring_set,
+	.set_passwd		= ril_call_barring_set_passwd
+};
+
+void ril_call_barring_init(void)
+{
+	ofono_call_barring_driver_register(&driver);
+}
+
+void ril_call_barring_exit(void)
+{
+	ofono_call_barring_driver_unregister(&driver);
+}

ofono/drivers/rilmodem/call-forwarding.c

@@ -3,7 +3,7 @@
  *  oFono - Open Source Telephony
  *
  *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
- *  Copyright (C) 2013 Jolla Ltd
+ *  Copyright (C) 2013-2014 Jolla Ltd
  *  Contact: Jussi Kangas <jussi.kangas@tieto.com>
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -89,16 +89,13 @@ static void ril_registration(struct ofono_call_forwarding *cf, int type,
 
 	parcel_w_int32(&rilp, type);
 
-	/* Modem seems to respond with error to all queries
+	/*
+	 * Modem seems to respond with error to all queries
 	 * or settings made with bearer class
 	 * BEARER_CLASS_DEFAULT. Design decision: If given
 	 * class is BEARER_CLASS_DEFAULT let's map it to
-	 * SERVICE_CLASS_VOICE effectively making it the
-	 * default bearer. This in line with API which is
-	 * contains only voice anyways. TODO: Checkout
-	 * the behaviour with final modem
+	 * BEARER_CLASS_VOICE as per RIL design.
 	*/
-
 	if (cls == BEARER_CLASS_DEFAULT)
 		cls = BEARER_CLASS_VOICE;
 
@@ -137,16 +134,13 @@ static void ril_send_forward_cmd(struct ofono_call_forwarding *cf,
 
 	parcel_w_int32(&rilp, type);
 
-	/* Modem seems to respond with error to all queries
+	/*
+	 * Modem seems to respond with error to all queries
 	 * or settings made with bearer class
 	 * BEARER_CLASS_DEFAULT. Design decision: If given
 	 * class is BEARER_CLASS_DEFAULT let's map it to
-	 * SERVICE_CLASS_VOICE effectively making it the
-	 * default bearer. This in line with API which is
-	 * contains only voice anyways. TODO: Checkout
-	 * the behaviour with final modem
+	 * BEARER_CLASS_VOICE as per RIL design.
 	*/
-
 	if (cls == BEARER_CLASS_DEFAULT)
 		cls = BEARER_CLASS_VOICE;
 
@@ -220,7 +214,7 @@ static void ril_query_cb(struct ril_msg *message, gpointer user_data)
 				nmbr_of_resps);
 
 		for (i = 0; i < nmbr_of_resps; i++) {
-			const char *str;
+			char *str = NULL;
 
 			list[i].status =  parcel_r_int32(&rilp);
 
@@ -231,22 +225,19 @@ static void ril_query_cb(struct ril_msg *message, gpointer user_data)
 			list[i].phone_number.type = parcel_r_int32(&rilp);
 
 			str = parcel_r_string(&rilp);
-
 			if (str) {
-
 				strncpy(list[i].phone_number.number,
 					str,
 					OFONO_MAX_PHONE_NUMBER_LENGTH);
 
 				list[i].phone_number.number[
 					OFONO_MAX_PHONE_NUMBER_LENGTH] = '\0';
-
-				list[i].time = parcel_r_int32(&rilp);
+				g_free(str);
 			}
-
+			list[i].time = parcel_r_int32(&rilp);
 		}
 
-		CALLBACK_WITH_SUCCESS(cb, 1, list, cbd->data);
+		CALLBACK_WITH_SUCCESS(cb, nmbr_of_resps, list, cbd->data);
 
 		g_free(list);
 	} else {
@@ -272,18 +263,15 @@ static void ril_query(struct ofono_call_forwarding *cf, int type, int cls,
 
 	parcel_w_int32(&rilp, type);
 
-	/* Modem seems to respond with error to all queries
+	/*
+	 * Modem seems to respond with error to all queries
 	 * or settings made with bearer class
 	 * BEARER_CLASS_DEFAULT. Design decision: If given
 	 * class is BEARER_CLASS_DEFAULT let's map it to
-	 * SERVICE_CLASS_VOICE effectively making it the
-	 * default bearer. This in line with API which is
-	 * contains only voice anyways. TODO: Checkout
-	 * the behaviour with final modem
+	 * SERVICE_CLASS_NONE as per RIL design.
 	*/
-
 	if (cls == BEARER_CLASS_DEFAULT)
-		cls = BEARER_CLASS_VOICE;
+		cls = SERVICE_CLASS_NONE;
 
 	parcel_w_int32(&rilp, cls);
 
@@ -351,10 +339,10 @@ static struct ofono_call_forwarding_driver driver = {
 	.probe			= ril_call_forwarding_probe,
 	.remove			= ril_call_forwarding_remove,
 	.erasure		= ril_erasure,
-	.deactivation	= ril_deactivate,
+	.deactivation		= ril_deactivate,
 	.query			= ril_query,
-	.registration	= ril_registration,
-	.activation	= ril_activate
+	.registration		= ril_registration,
+	.activation		= ril_activate
 };
 
 void ril_call_forwarding_init(void)

ofono/drivers/rilmodem/devinfo.c

@@ -42,9 +42,8 @@
 #include "rilmodem.h"
 
 /*
- * TODO: The functions in this file are stubbed out, and
- * will need to be re-worked to talk to the /gril layer
- * in order to get real values from RILD.
+ * TODO: No public RIL api to query manufacturer or model.
+ * Check where to get, could /system/build.prop be updated to have good values?
  */
 guint timer_id;
 
@@ -52,30 +51,14 @@ static void ril_query_manufacturer(struct ofono_devinfo *info,
 					ofono_devinfo_query_cb_t cb,
 					void *data)
 {
-	const char *attr = "Fake Manufacturer";
-	struct cb_data *cbd = cb_data_new(cb, data);
-	struct ofono_error error;
-	decode_ril_error(&error, "OK");
-
-	cb(&error, attr, cbd->data);
-
-	/* Note: this will need to change if cbd passed to gril layer */
-	g_free(cbd);
+	CALLBACK_WITH_FAILURE(cb, "", data);
 }
 
 static void ril_query_model(struct ofono_devinfo *info,
 				ofono_devinfo_query_cb_t cb,
 				void *data)
 {
-	const char *attr = "Fake Modem Model";
-	struct cb_data *cbd = cb_data_new(cb, data);
-	struct ofono_error error;
-	decode_ril_error(&error, "OK");
-
-	cb(&error, attr, cbd->data);
-
-	/* Note: this will need to change if cbd passed to gril layer */
-	g_free(cbd);
+	CALLBACK_WITH_FAILURE(cb, "", data);
 }
 
 static void query_revision_cb(struct ril_msg *message, gpointer user_data)
@@ -98,6 +81,7 @@ static void query_revision_cb(struct ril_msg *message, gpointer user_data)
 	revision = parcel_r_string(&rilp);
 
 	cb(&error, revision, cbd->data);
+	g_free(revision);
 }
 
 static void ril_query_revision(struct ofono_devinfo *info,
@@ -137,10 +121,10 @@ static void query_serial_cb(struct ril_msg *message, gpointer user_data)
 	}
 
 	ril_util_init_parcel(message, &rilp);
-
 	imei = parcel_r_string(&rilp);
 
 	cb(&error, imei, cbd->data);
+	g_free(imei);
 }
 
 static void ril_query_serial(struct ofono_devinfo *info,

ofono/drivers/rilmodem/gprs-context.c

@@ -43,8 +43,16 @@
 #include "grilrequest.h"
 #include "grilunsol.h"
 
+#include "common.h"
+
 #include "rilmodem.h"
 
+enum data_call_state {
+	DATA_CALL_INACTIVE,
+	DATA_CALL_LINK_DOWN,
+	DATA_CALL_ACTIVE,
+};
+
 enum state {
 	STATE_IDLE,
 	STATE_ENABLING,
@@ -58,24 +66,111 @@ struct gprs_context_data {
 	gint active_rild_cid;
 	enum state state;
 	guint regid;
+	struct unsol_data_call_list *old_list;
+	guint prev_active_status;
 };
 
-static void ril_gprs_context_deactivate_primary(struct ofono_gprs_context *gc,
-						unsigned int id,
-						ofono_gprs_context_cb_t cb, void *data);
-
 static void set_context_disconnected(struct gprs_context_data *gcd)
 {
-	DBG("");
-
 	gcd->active_ctx_cid = -1;
 	gcd->active_rild_cid = -1;
 	gcd->state = STATE_IDLE;
 }
 
-static void disconnect_context(struct ofono_gprs_context *gc)
+static void ril_gprs_split_ip_by_protocol(char **ip_array,
+						char ***split_ip_addr,
+						char ***split_ipv6_addr,
+						char **ip_addr)
 {
-	ril_gprs_context_deactivate_primary(gc, 0, NULL, NULL);
+	const char ipv6_delimiter = ':';
+	const char ip_delimiter = '.';
+	int i;
+
+	*split_ipv6_addr = *split_ip_addr = NULL;
+	for (i=0; i< g_strv_length(ip_array); i++) {
+		if (strchr(ip_array[i], ipv6_delimiter)) {
+			if (*split_ipv6_addr == NULL) {
+				*split_ipv6_addr = g_strsplit(
+							ip_array[i], "/",2);
+			}
+		} else if (strchr(ip_array[i], ip_delimiter)) {
+			if (*split_ip_addr == NULL) {
+				*ip_addr = g_strdup(ip_array[i]);
+				*split_ip_addr = g_strsplit(
+							ip_array[i], "/", 2);
+			}
+		}
+	}
+}
+
+static void ril_gprs_split_gw_by_protocol(char **gw_array, char **ip_gw,
+								char **ipv6_gw)
+{
+	const char ipv6_delimiter = ':';
+	const char ip_delimiter = '.';
+	int i;
+
+	*ip_gw = *ipv6_gw = NULL;
+	for (i=0; i< g_strv_length(gw_array); i++) {
+		if (strchr(gw_array[i],ipv6_delimiter)) {
+			if (*ipv6_gw == NULL) {
+				*ipv6_gw = g_strdup(gw_array[i]);
+			}
+		} else if (strchr(gw_array[i],ip_delimiter)) {
+			if (*ip_gw == NULL)
+				*ip_gw = g_strdup(gw_array[i]);
+		}
+	}
+}
+
+static void ril_gprs_split_dns_by_protocol(char **dns_array, char ***dns_addr,
+							char ***dns_ipv6_addr)
+{
+	const char ipv6_delimiter = ':';
+	const char ip_delimiter = '.';
+	char *temp = NULL;
+	char *temp1 = NULL;
+	char *dnsip = NULL;
+	char *dnsipv6 = NULL;
+	int i, dnsip_len, dnsipv6_len;
+
+	dnsip_len = dnsipv6_len = 0;
+
+	for (i=0; i< g_strv_length(dns_array); i++) {
+		if (strchr(dns_array[i],ipv6_delimiter)) {
+			if (dnsipv6 == NULL) {
+				dnsipv6 = g_strdup(dns_array[i]);
+			} else {
+				temp = g_strconcat(dnsipv6, ",", NULL);
+				g_free(dnsipv6);
+				temp1 = g_strconcat(temp, dns_array[i], NULL);
+				g_free(temp);
+				dnsipv6 = temp1;
+			}
+			dnsipv6_len++;
+		} else if (strchr(dns_array[i],ip_delimiter)) {
+			if (dnsip == NULL) {
+				dnsip = g_strdup(dns_array[i]);
+			} else {
+				temp = g_strconcat(dnsip, ",", NULL);
+				g_free(dnsip);
+				temp1 = g_strconcat(temp, dns_array[i], NULL);
+				g_free(temp);
+				dnsip = temp1;
+
+			}
+			dnsip_len++;
+		}
+	}
+
+	if (dnsip)
+		*dns_addr = g_strsplit(dnsip, ",", dnsip_len);
+
+	if (dnsipv6)
+		*dns_ipv6_addr = g_strsplit(dnsipv6, ",", dnsipv6_len);
+
+	g_free(dnsip);
+	g_free(dnsipv6);
 }
 
 static void ril_gprs_context_call_list_changed(struct ril_msg *message,
@@ -85,8 +180,8 @@ static void ril_gprs_context_call_list_changed(struct ril_msg *message,
 	struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);
 	struct data_call *call = NULL;
 	struct unsol_data_call_list *unsol;
-	gboolean active_cid_found = FALSE;
 	gboolean disconnect = FALSE;
+	gboolean signal = FALSE;
 	GSList *iterator = NULL;
 	struct ofono_error error;
 
@@ -95,28 +190,164 @@ static void ril_gprs_context_call_list_changed(struct ril_msg *message,
 	if (error.type != OFONO_ERROR_TYPE_NO_ERROR)
 		goto error;
 
+	if (g_ril_unsol_cmp_dcl(unsol,gcd->old_list,gcd->active_rild_cid))
+		goto error;
+
+	g_ril_unsol_free_data_call_list(gcd->old_list);
+	gcd->old_list = unsol;
+
 	DBG("number of call in call_list_changed is: %d", unsol->num);
 
 	for (iterator = unsol->call_list; iterator; iterator = iterator->next) {
 		call = (struct data_call *) iterator->data;
 
-		if (call->cid == gcd->active_rild_cid) {
-			active_cid_found = TRUE;
+		/*
+		 * Every context receives notifications about all data calls
+		 * but should only handle its own.
+		 */
+		if (call->cid != gcd->active_rild_cid)
+			continue;
 
-			if (call->active == 0) {
-				disconnect = TRUE;
-				ofono_gprs_context_deactivated(gc, gcd->active_ctx_cid);
+		if (call->active == DATA_CALL_LINK_DOWN)
+			gcd->prev_active_status = call->active;
+
+		if (call->status != 0)
+			ofono_info("data call status:%d", call->status);
+
+		if (call->active == DATA_CALL_INACTIVE) {
+			disconnect = TRUE;
+			gcd->prev_active_status = call->active;
+			ofono_gprs_context_deactivated(gc, gcd->active_ctx_cid);
+			break;
+		}
+
+		if (call->active == DATA_CALL_ACTIVE) {
+			int protocol = -1;
+
+			if (gcd->prev_active_status != DATA_CALL_LINK_DOWN)
+				signal = TRUE;
+
+			gcd->prev_active_status = call->active;
+
+			if (call->type)
+				protocol = ril_protocol_string_to_ofono_protocol(call->type);
+
+			if (call->ifname)
+				ofono_gprs_context_set_interface(gc,
+								call->ifname);
+
+			if (call->addresses) {
+				char **split_ip_addr = NULL;
+				char **ip_array = NULL;
+				char **split_ipv6_addr = NULL;
+				char *ip_addr = NULL;
+
+				/*addresses to an array*/
+				ip_array = g_strsplit(call->addresses, " ",-1);
+
+				/*pick 1 address of each protocol*/
+				ril_gprs_split_ip_by_protocol(ip_array,
+								&split_ip_addr,
+								&split_ipv6_addr,
+								&ip_addr);
+
+				if ((protocol == OFONO_GPRS_PROTO_IPV4V6 ||
+						protocol == OFONO_GPRS_PROTO_IPV6)
+						&& split_ipv6_addr != NULL){
+
+					ofono_gprs_context_set_ipv6_address(gc,
+							split_ipv6_addr[0]);
+				}
+
+				if ((protocol == OFONO_GPRS_PROTO_IPV4V6 ||
+						protocol == OFONO_GPRS_PROTO_IP)
+						&& split_ip_addr != NULL) {
+
+					ofono_gprs_context_set_ipv4_netmask(gc,
+						ril_util_get_netmask(ip_addr));
+					ofono_gprs_context_set_ipv4_address(gc,
+							split_ip_addr[0], TRUE);
+				}
+
+				g_strfreev(split_ip_addr);
+				g_strfreev(split_ipv6_addr);
+				g_strfreev(ip_array);
+				g_free(ip_addr);
 			}
 
+			if (call->gateways) {
+				char **gw_array = NULL;
+				char *ip_gw = NULL;
+				char *ipv6_gw = NULL;
+				/*addresses to an array*/
+				gw_array = g_strsplit(call->gateways, " ", -1);
+
+				/*pick 1 gw for each protocol*/
+				ril_gprs_split_gw_by_protocol(gw_array, &ip_gw,
+								&ipv6_gw);
+
+				if ((protocol == OFONO_GPRS_PROTO_IPV4V6 ||
+						protocol == OFONO_GPRS_PROTO_IPV6)
+						&& ipv6_gw != NULL)
+					ofono_gprs_context_set_ipv6_gateway(gc,
+								ipv6_gw);
+
+				if ((protocol == OFONO_GPRS_PROTO_IPV4V6 ||
+						protocol == OFONO_GPRS_PROTO_IP)
+						&& ip_gw != NULL)
+					ofono_gprs_context_set_ipv4_gateway(gc,
+								ip_gw);
+
+				g_strfreev(gw_array);
+				g_free(ip_gw);
+				g_free(ipv6_gw);
+			}
+
+			if (call->dnses) {
+				char **dns_array = NULL;
+				char **dns_ip = NULL;
+				char **dns_ipv6 = NULL;
+
+				/*addresses to an array*/
+				dns_array = g_strsplit(call->dnses, " ", -1);
+
+				/*split based on protocol*/
+				ril_gprs_split_dns_by_protocol(dns_array,
+								&dns_ip,
+								&dns_ipv6);
+
+				if ((protocol == OFONO_GPRS_PROTO_IPV4V6 ||
+						protocol == OFONO_GPRS_PROTO_IPV6)
+						&& dns_ipv6 != NULL)
+					ofono_gprs_context_set_ipv6_dns_servers(
+						gc, (const char **) dns_ipv6);
+
+				if ((protocol == OFONO_GPRS_PROTO_IPV4V6 ||
+						protocol == OFONO_GPRS_PROTO_IP)
+						&& dns_ip != NULL)
+					ofono_gprs_context_set_ipv4_dns_servers(
+						gc, (const char**)dns_ip);
+
+				g_strfreev(dns_ip);
+				g_strfreev(dns_ipv6);
+				g_strfreev(dns_array);
+			}
 			break;
 		}
 	}
 
-	if (disconnect || active_cid_found == FALSE) {
+	if (disconnect) {
 		ofono_error("Clearing active context");
 		set_context_disconnected(gcd);
+		gcd->old_list = NULL;
+		goto error;
 	}
 
+	if (signal)
+		ofono_gprs_context_signal_change(gc, gcd->active_ctx_cid);
+
+	return;
+
 error:
 	g_ril_unsol_free_data_call_list(unsol);
 }
@@ -130,6 +361,12 @@ static void ril_setup_data_call_cb(struct ril_msg *message, gpointer user_data)
 	struct ofono_error error;
 	struct reply_setup_data_call *reply = NULL;
 	char **split_ip_addr = NULL;
+	char **split_ipv6_addr = NULL;
+	char* ip_addr = NULL;
+	char* ip_gw = NULL;
+	char* ipv6_gw = NULL;
+	char** dns_addr = NULL;
+	char** dns_ipv6_addr = NULL;
 
 	ofono_info("setting up data call");
 
@@ -149,10 +386,7 @@ static void ril_setup_data_call_cb(struct ril_msg *message, gpointer user_data)
 	gcd->active_rild_cid = reply->cid;
 
 	if (error.type != OFONO_ERROR_TYPE_NO_ERROR) {
-		if (gcd->active_rild_cid != -1) {
-			ofono_error("no active context. disconnect");
-			disconnect_context(gc);
-		}
+		ofono_error("no active context. disconnect");
 		goto error;
 	}
 
@@ -164,24 +398,16 @@ static void ril_setup_data_call_cb(struct ril_msg *message, gpointer user_data)
 		error.type = OFONO_ERROR_TYPE_FAILURE;
 		error.error = reply->status;
 
-		set_context_disconnected(gcd);
 		goto error;
 	}
 
-	/*
-	 * TODO: consier moving this into parse_data_reply
-	 *
-	 * Note - the address may optionally include a prefix size
-	 * ( Eg. "/30" ).  As this confuses NetworkManager, we
-	 * explicitly strip any prefix after calculating the netmask.
-	 */
-	split_ip_addr = g_strsplit(reply->ip_addrs[0], "/", 2);
+	/*check the ip address protocol*/
+	ril_gprs_split_ip_by_protocol(reply->ip_addrs, &split_ip_addr,
+						&split_ipv6_addr, &ip_addr);
 
-	/* TODO: see note above re: invalid messages... */
-	if (split_ip_addr[0] == NULL) {
-		ofono_error("%s: invalid IP address field returned: %s",
-				__func__,
-				reply->ip_addrs[0]);
+	if (split_ip_addr == NULL && split_ipv6_addr == NULL) {
+		ofono_error("%s: No IP address returned",
+				__func__);
 
 		error.type = OFONO_ERROR_TYPE_FAILURE;
 		error.error = EINVAL;
@@ -194,33 +420,55 @@ static void ril_setup_data_call_cb(struct ril_msg *message, gpointer user_data)
 
 	ofono_gprs_context_set_interface(gc, reply->ifname);
 
+	ril_gprs_split_gw_by_protocol(reply->gateways, &ip_gw, &ipv6_gw);
+
+	ril_gprs_split_dns_by_protocol(reply->dns_addresses, &dns_addr,
+								&dns_ipv6_addr);
+
 	/* TODO:
-	 * RILD can return multiple addresses; oFono only supports
-	 * setting a single IPv4 address.  At this time, we only
-	 * use the first address.  It's possible that a RIL may
-	 * just specify the end-points of the point-to-point
-	 * connection, in which case this code will need to
-	 * changed to handle such a device.
+	 * RILD can return multiple addresses; oFono only supports setting
+	 * a single IPv4 and single IPV6 address. At this time, we only use
+	 * the first address. It's possible that a RIL may just specify
+	 * the end-points of the point-to-point connection, in which case this
+	 * code will need to changed to handle such a device.
 	 */
-	ofono_gprs_context_set_ipv4_netmask(gc,
-			ril_util_get_netmask(reply->ip_addrs[0]));
 
-	ofono_gprs_context_set_ipv4_address(gc, split_ip_addr[0], TRUE);
-	ofono_gprs_context_set_ipv4_gateway(gc, reply->gateways[0]);
+	if (split_ipv6_addr != NULL &&
+			(reply->protocol == OFONO_GPRS_PROTO_IPV6 ||
+			reply->protocol == OFONO_GPRS_PROTO_IPV4V6)) {
 
-	ofono_gprs_context_set_ipv4_dns_servers(gc,
-						(const char **) reply->dns_addresses);
+		ofono_gprs_context_set_ipv6_address(gc, split_ipv6_addr[0]);
+		ofono_gprs_context_set_ipv6_gateway(gc, ipv6_gw);
+		ofono_gprs_context_set_ipv6_dns_servers(gc,
+						(const char **) dns_ipv6_addr);
+	}
 
+	if (split_ip_addr != NULL &&
+			(reply->protocol == OFONO_GPRS_PROTO_IP ||
+			reply->protocol == OFONO_GPRS_PROTO_IPV4V6)) {
+		ofono_gprs_context_set_ipv4_netmask(gc,
+					ril_util_get_netmask(ip_addr));
+		ofono_gprs_context_set_ipv4_address(gc, split_ip_addr[0], TRUE);
+		ofono_gprs_context_set_ipv4_gateway(gc, ip_gw);
+		ofono_gprs_context_set_ipv4_dns_servers(gc,
+						(const char **) dns_addr);
+	}
 error:
 	g_ril_reply_free_setup_data_call(reply);
 	g_strfreev(split_ip_addr);
+	g_strfreev(split_ipv6_addr);
+	g_strfreev(dns_addr);
+	g_strfreev(dns_ipv6_addr);
+	g_free(ip_addr);
+	g_free(ip_gw);
+	g_free(ipv6_gw);
 
 	cb(&error, cbd->data);
 }
 
 static void ril_gprs_context_activate_primary(struct ofono_gprs_context *gc,
-						const struct ofono_gprs_primary_context *ctx,
-						ofono_gprs_context_cb_t cb, void *data)
+				const struct ofono_gprs_primary_context *ctx,
+				ofono_gprs_context_cb_t cb, void *data)
 {
 	struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);
 	struct cb_data *cbd = cb_data_new(cb, data);
@@ -229,9 +477,19 @@ static void ril_gprs_context_activate_primary(struct ofono_gprs_context *gc,
 	struct ofono_error error;
 	int reqid = RIL_REQUEST_SETUP_DATA_CALL;
 	int ret = 0;
+	int netreg_status;
+	int roaming = NETWORK_REGISTRATION_STATUS_ROAMING;
 
 	ofono_info("Activating context: %d", ctx->cid);
 
+	/* Let's make sure that we aren't connecting when roaming not allowed */
+	netreg_status = get_current_network_status();
+	if (netreg_status == roaming) {
+		if (!ril_roaming_allowed() && (roaming
+				== check_if_really_roaming(netreg_status)))
+			goto exit;
+	}
+
 	cbd->user = gc;
 
 	/* TODO: implement radio technology selection. */
@@ -245,6 +503,7 @@ static void ril_gprs_context_activate_primary(struct ofono_gprs_context *gc,
 	request.username = g_strdup(ctx->username);
 	request.password = g_strdup(ctx->password);
 	request.auth_type = RIL_AUTH_BOTH;
+
 	request.protocol = ctx->proto;
 
 	if (g_ril_request_setup_data_call(gcd->ril,
@@ -273,7 +532,7 @@ error:
 	g_free(request.apn);
 	g_free(request.username);
 	g_free(request.password);
-
+exit:
 	if (ret <= 0) {
 		ofono_error("Send RIL_REQUEST_SETUP_DATA_CALL failed.");
 
@@ -284,7 +543,8 @@ error:
 	}
 }
 
-static void ril_deactivate_data_call_cb(struct ril_msg *message, gpointer user_data)
+static void ril_deactivate_data_call_cb(struct ril_msg *message,
+						gpointer user_data)
 {
 	struct cb_data *cbd = user_data;
 	ofono_gprs_context_cb_t cb = cbd->cb;
@@ -322,7 +582,8 @@ static void ril_deactivate_data_call_cb(struct ril_msg *message, gpointer user_d
 
 static void ril_gprs_context_deactivate_primary(struct ofono_gprs_context *gc,
 						unsigned int id,
-						ofono_gprs_context_cb_t cb, void *data)
+						ofono_gprs_context_cb_t cb,
+						void *data)
 {
 	struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);
 	struct cb_data *cbd = NULL;
@@ -375,6 +636,7 @@ error:
 	if (ret <= 0) {
 		ofono_error("Send RIL_REQUEST_DEACTIVATE_DATA_CALL failed.");
 		g_free(cbd);
+
 		if (cb)
 			CALLBACK_WITH_FAILURE(cb, data);
 	}
@@ -402,7 +664,6 @@ static int ril_gprs_context_probe(struct ofono_gprs_context *gc,
 	set_context_disconnected(gcd);
 
 	ofono_gprs_context_set_data(gc, gcd);
-	gcd->regid = -1;
 
 	gcd->regid = g_ril_register(gcd->ril, RIL_UNSOL_DATA_CALL_LIST_CHANGED,
 					ril_gprs_context_call_list_changed, gc);
@@ -415,14 +676,15 @@ static void ril_gprs_context_remove(struct ofono_gprs_context *gc)
 
 	DBG("");
 
-	if (gcd->state != STATE_IDLE) {
+	g_ril_unsol_free_data_call_list(gcd->old_list);
+
+	if (gcd->state != STATE_IDLE)
 		ril_gprs_context_detach_shutdown(gc, 0);
-	}
 
 	ofono_gprs_context_set_data(gc, NULL);
-	
+
 	if (gcd->regid != -1)
-		g_ril_unregister(gcd->ril,gcd->regid);
+		g_ril_unregister(gcd->ril, gcd->regid);
 
 	g_ril_unref(gcd->ril);
 	g_free(gcd);
@@ -432,9 +694,9 @@ static struct ofono_gprs_context_driver driver = {
 	.name			= RILMODEM,
 	.probe			= ril_gprs_context_probe,
 	.remove			= ril_gprs_context_remove,
-	.activate_primary       = ril_gprs_context_activate_primary,
-	.deactivate_primary     = ril_gprs_context_deactivate_primary,
-	.detach_shutdown        = ril_gprs_context_detach_shutdown,
+	.activate_primary	= ril_gprs_context_activate_primary,
+	.deactivate_primary	= ril_gprs_context_deactivate_primary,
+	.detach_shutdown	= ril_gprs_context_detach_shutdown,
 };
 
 void ril_gprs_context_init(void)

ofono/drivers/rilmodem/gprs.c

@@ -45,6 +45,8 @@
 #include "rilmodem.h"
 
 #include <ofono/netreg.h>
+#include <ofono/sim.h>
+#include "storage.h"
 
 /*
  * This module is the ofono_gprs_driver implementation for rilmodem.
@@ -67,12 +69,18 @@ struct gprs_data {
 	GRil *ril;
 	gboolean ofono_attached;
 	int max_cids;
-	int rild_status;
-	gboolean notified;
+	int rild_status; /* Driver Status */
 	guint registerid;
 	guint timer_id;
 };
 
+/* Following constants are purely to improve readability */
+static const int roaming = NETWORK_REGISTRATION_STATUS_ROAMING;
+static const int registered = NETWORK_REGISTRATION_STATUS_REGISTERED;
+
+/*if we have called ofono_gprs_register or not*/
+static gboolean ofono_registered;
+
 static void ril_gprs_registration_status(struct ofono_gprs *gprs,
 					ofono_gprs_status_cb_t cb,
 					void *data);
@@ -81,7 +89,10 @@ static void ril_gprs_state_change(struct ril_msg *message, gpointer user_data)
 {
 	struct ofono_gprs *gprs = user_data;
 
-	g_assert(message->req == RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED);
+	g_assert(message->req ==
+				RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED);
+
+	DBG("");
 
 	/* We need to notify core always to cover situations when
 	 * connection drops temporarily for example when user is
@@ -97,6 +108,7 @@ static gboolean ril_gprs_set_attached_callback(gpointer user_data)
 	ofono_gprs_cb_t cb = cbd->cb;
 	struct ofono_gprs *gprs = cbd->user;
 	struct gprs_data *gd = ofono_gprs_get_data(gprs);
+
 	DBG("");
 
 	gd->timer_id = 0;
@@ -133,7 +145,6 @@ static void ril_gprs_set_attached(struct ofono_gprs *gprs, int attached,
 
 	cbd->user = gprs;
 
-	ril_gprs_registration_status(gprs, NULL, NULL);
 	/*
 	* However we cannot respond immediately, since core sets the
 	* value of driver_attached after calling set_attached and that
@@ -144,6 +155,30 @@ static void ril_gprs_set_attached(struct ofono_gprs *gprs, int attached,
 						cbd);
 }
 
+gboolean ril_roaming_allowed()
+{
+	GError *error;
+	error = NULL;
+	GKeyFile *settings;
+	struct ofono_sim *sim;
+
+	sim = get_sim();
+	const char *imsi = ofono_sim_get_imsi(sim);
+	settings = storage_open(imsi, "gprs");
+	gboolean roaming_allowed = g_key_file_get_boolean(settings,
+							"Settings",
+							"RoamingAllowed",
+							&error);
+
+	if (error)
+		g_error_free(error);
+
+	storage_close(imsi, "gprs", settings, FALSE);
+
+	DBG("roaming_allowed: %d", roaming_allowed);
+	return roaming_allowed;
+}
+
 static void ril_data_reg_cb(struct ril_msg *message, gpointer user_data)
 {
 	struct cb_data *cbd = user_data;
@@ -151,9 +186,9 @@ static void ril_data_reg_cb(struct ril_msg *message, gpointer user_data)
 	struct ofono_gprs *gprs = cbd->user;
 	struct gprs_data *gd = ofono_gprs_get_data(gprs);
 	struct ofono_error error;
-	int status, lac, ci, tech;
+	int lac, ci, tech;
 	int max_cids = 1;
-	int id = RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED;
+	int status = -1;
 
 	if (gd && message->error == RIL_E_SUCCESS) {
 		decode_ril_error(&error, "OK");
@@ -162,24 +197,22 @@ static void ril_data_reg_cb(struct ril_msg *message, gpointer user_data)
 				ril_error_to_string(message->error));
 		decode_ril_error(&error, "FAIL");
 		error.error = message->error;
-		status = -1;
-		goto error;
+		goto exit;
 	}
 
 	if (ril_util_parse_reg(gd->ril, message, &status,
 				&lac, &ci, &tech, &max_cids) == FALSE) {
 		ofono_error("Failure parsing data registration response.");
 		decode_ril_error(&error, "FAIL");
-		status = -1;
-		goto error;
+		goto exit;
 	}
 
-	if (gd->rild_status == -1) {
-		ofono_gprs_register(gprs);
+	if (status > 10)
+		status = status - 10;
 
-		DBG("Starting to listen network status");
-		gd->registerid = g_ril_register(gd->ril,
-			id, ril_gprs_state_change, gprs);
+	if (!ofono_registered) {
+		ofono_gprs_register(gprs);
+		ofono_registered = TRUE;
 	}
 
 	if (max_cids > gd->max_cids) {
@@ -188,70 +221,129 @@ static void ril_data_reg_cb(struct ril_msg *message, gpointer user_data)
 		ofono_gprs_set_cid_range(gprs, 1, max_cids);
 	}
 
-	ofono_info("data registration status is %d", status);
-
-	if (status == NETWORK_REGISTRATION_STATUS_ROAMING)
+	if (status == roaming)
 		status = check_if_really_roaming(status);
 
-	if (gd->ofono_attached && !gd->notified) {
-		if (status == NETWORK_REGISTRATION_STATUS_ROAMING ||
-			status == NETWORK_REGISTRATION_STATUS_REGISTERED) {
-			DBG("connection becomes available");
+	/* Let's minimize logging */
+	if (status != gd->rild_status)
+		ofono_info("data reg changes %d (%d), attached %d",
+				status, gd->rild_status, gd->ofono_attached);
+
+	/* Must be attached if registered or roaming */
+	if ((gd->rild_status != registered) && (gd->rild_status != roaming)) {
+		if (status == registered)
+			gd->ofono_attached = TRUE;
+		else if ((status == roaming) && (ril_roaming_allowed() == TRUE))
 			gd->ofono_attached = TRUE;
-			ofono_gprs_status_notify(gprs, status);
-			gd->notified = TRUE;
-			gd->rild_status = status;
-		}
-		goto error;
 	}
 
-	if (gd->ofono_attached &&
-			status != NETWORK_REGISTRATION_STATUS_SEARCHING) {
-		DBG("ofono attached, start faking responses");
-		if (status != NETWORK_REGISTRATION_STATUS_ROAMING) {
+	if (!ofono_modem_get_online(ofono_gprs_get_modem(gprs)))
+		gd->ofono_attached = FALSE;
+
+	/* if unsolicitated and no state change let's not notify core */
+	if ((status == gd->rild_status) && gd->ofono_attached)
+		goto cb_out;
+
+	if (!gd->ofono_attached) {
+		if (!cb) {
+			if (status == roaming) {
+				if (ril_roaming_allowed() == FALSE)
+					ofono_gprs_detached_notify(gprs);
+
+				/*
+				 * This prevents core ending
+				 * into eternal loop with driver
+				 */
+				decode_ril_error(&error, "FAIL");
+			}
+
+			ofono_gprs_status_notify(gprs, status);
+
+		} else {
 			/*
-			* Only core can succesfully drop the connection
-			* If we drop the connection from here it leads
-			* to race situation where core asks context
-			* deactivation and at the same time we get
-			* Registered notification from modem.
-			*/
-			status = NETWORK_REGISTRATION_STATUS_REGISTERED;
+			 * This prevents core ending
+			 * into eternal loop with driver
+			 */
+			decode_ril_error(&error, "FAIL");
 		}
 
-		if (gd->registerid != -1)
-			g_ril_unregister(gd->ril, gd->registerid);
-		gd->registerid = -1;
-	} else {
-		/*
-		 * Client is not approving succesful result
-		 * This covers the situation when context is
-		 * active in roaming situation and client closes
-		 * it directly by calling RoamingAllowed in API
-		 */
-		DBG("data registration status is %d", status);
-
-		if (status != NETWORK_REGISTRATION_STATUS_SEARCHING) {
-			DBG("ofono not attached, notify core");
-			status = NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
-			ofono_gprs_detached_notify(gprs);
-			gd->notified = FALSE;
-			gd->ofono_attached = FALSE;
-		} else if (gd->notified) {
-			DBG("hide the searching state");
-			status = NETWORK_REGISTRATION_STATUS_REGISTERED;
-			ofono_gprs_status_notify(gprs, status);
-			gd->ofono_attached = TRUE;
-		}
+		gd->rild_status = status;
+		goto exit;
 	}
 
+	if (!cb)
+		ofono_gprs_status_notify(gprs, status);
+
 	gd->rild_status = status;
 
-error:
+exit:
+	DBG("data reg status %d, rild_status %d, attached %d",
+		status, gd->rild_status, gd->ofono_attached);
+cb_out:
 	if (cb)
 		cb(&error, status, cbd->data);
 }
 
+static void ril_data_probe_reg_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	struct ofono_gprs *gprs = cbd->user;
+	struct gprs_data *gd = ofono_gprs_get_data(gprs);
+	struct ofono_error error;
+	int status, lac, ci, tech;
+	int max_cids = 1;
+	int id = RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED;
+
+	DBG("");
+
+	if (!(gd && message->error == RIL_E_SUCCESS)) {
+		ofono_error("ril_data_reg_cb: reply failure: %s",
+				ril_error_to_string(message->error));
+		decode_ril_error(&error, "FAIL");
+		error.error = message->error;
+		status = NETWORK_REGISTRATION_STATUS_UNKNOWN;
+		goto out;
+	}
+
+	decode_ril_error(&error, "OK");
+	status = -1;
+
+	if (ril_util_parse_reg(gd->ril, message, &status,
+				&lac, &ci, &tech, &max_cids) == FALSE) {
+		ofono_error("Failure parsing data registration response.");
+		decode_ril_error(&error, "FAIL");
+
+		if (status == -1)
+			status = NETWORK_REGISTRATION_STATUS_UNKNOWN;
+
+		goto out;
+	}
+
+	if (status > 10)
+		status = status - 10;
+
+	ofono_gprs_register(gprs);
+
+	ofono_registered = TRUE;
+
+	if (max_cids > gd->max_cids) {
+		DBG("Setting max cids to %d", max_cids);
+		gd->max_cids = max_cids;
+		ofono_gprs_set_cid_range(gprs, 1, max_cids);
+	}
+
+	if (status == roaming)
+		status = check_if_really_roaming(status);
+
+out:
+	ofono_info("data reg status probed %d", status);
+
+	gd->registerid = g_ril_register(gd->ril,
+			id, ril_gprs_state_change, gprs);
+
+	gd->rild_status = status;
+}
+
 static void ril_gprs_registration_status(struct ofono_gprs *gprs,
 					ofono_gprs_status_cb_t cb,
 					void *data)
@@ -261,20 +353,27 @@ static void ril_gprs_registration_status(struct ofono_gprs *gprs,
 	int request = RIL_REQUEST_DATA_REGISTRATION_STATE;
 	guint ret;
 
+	DBG("");
+
 	if (gd == NULL || cbd == NULL)
 		return;
 
 	cbd->user = gprs;
 
 	ret = g_ril_send(gd->ril, request,
-				NULL, 0, ril_data_reg_cb, cbd, g_free);
+				NULL, 0,
+				((gd->rild_status == -1)
+				? ril_data_probe_reg_cb
+				: ril_data_reg_cb), cbd, g_free);
 
 	g_ril_print_request_no_args(gd->ril, ret, request);
 
 	if (ret <= 0) {
-		ofono_error("Send RIL_REQUEST_DATA_RESTISTRATION_STATE failed.");
+		ofono_error("Send RIL_REQUEST_DATA_RESTISTRATION_STATE fail.");
 		g_free(cbd);
-		CALLBACK_WITH_FAILURE(cb, -1, data);
+
+		if (cb)
+			CALLBACK_WITH_FAILURE(cb, -1, data);
 	}
 }
 
@@ -292,9 +391,11 @@ static int ril_gprs_probe(struct ofono_gprs *gprs,
 	gd->ofono_attached = FALSE;
 	gd->max_cids = 0;
 	gd->rild_status = -1;
-	gd->notified = FALSE;
 	gd->registerid = -1;
 	gd->timer_id = 0;
+
+	ofono_registered = FALSE;
+
 	ofono_gprs_set_data(gprs, gd);
 
 	ril_gprs_registration_status(gprs, NULL, NULL);

ofono/drivers/rilmodem/network-registration.c

@@ -55,6 +55,7 @@ struct netreg_data {
 	guint nitz_timeout;
 	unsigned int vendor;
 	guint timer_id;
+	int corestatus; /* Registration status previously reported to core */
 };
 
 /* 27.007 Section 7.3 <stat> */
@@ -78,25 +79,20 @@ static void extract_mcc_mnc(const char *str, char *mcc, char *mnc)
 	mnc[OFONO_MAX_MNC_LENGTH] = '\0';
 }
 
-/*
- * TODO: The functions in this file are stubbed out, and
- * will need to be re-worked to talk to the /gril layer
- * in order to get real values from RILD.
- */
-
 static void ril_creg_cb(struct ril_msg *message, gpointer user_data)
 {
 	struct cb_data *cbd = user_data;
 	ofono_netreg_status_cb_t cb = cbd->cb;
 	struct netreg_data *nd = cbd->user;
 	struct ofono_error error;
-	int status, lac, ci, tech;
+	int status, logstatus, lac, ci, tech;
 
 	DBG("");
 
 	if (message->error != RIL_E_SUCCESS) {
 		decode_ril_error(&error, "FAIL");
-		ofono_error("Failed to pull registration state");
+		ofono_error("voice registration status query fail");
+		nd->corestatus = -1;
 		cb(&error, -1, -1, -1, -1, cbd->data);
 		return;
 	}
@@ -105,20 +101,31 @@ static void ril_creg_cb(struct ril_msg *message, gpointer user_data)
 
 	if (ril_util_parse_reg(nd->ril, message, &status,
 				&lac, &ci, &tech, NULL) == FALSE) {
+		DBG("voice registration status parsing fail");
+		nd->corestatus = -1;
 		CALLBACK_WITH_FAILURE(cb, -1, -1, -1, -1, cbd->data);
 		return;
 	}
 
-	DBG("voice registration status is %d", status);
-
 	if (status > 10)
 		status = status - 10;
 
+	logstatus = status;
+
 	if (status == NETWORK_REGISTRATION_STATUS_ROAMING)
 		status = check_if_really_roaming(status);
 
-	ofono_info("voice registration status is %d", status);
+	DBG("status:%d corestatus:%d", status, nd->corestatus);
 
+	if (status != logstatus)
+		ofono_info("voice registration modified %d (%d)",
+				status, logstatus);
+
+	if (nd->corestatus != status)
+		ofono_info("voice registration changes %d (%d)",
+				status, nd->corestatus);
+
+	nd->corestatus = status;
 	nd->tech = tech;
 	cb(&error, status, lac, ci, tech, cbd->data);
 }
@@ -128,15 +135,16 @@ static void ril_creg_notify(struct ofono_error *error, int status, int lac,
 {
 	struct ofono_netreg *netreg = user_data;
 
-        if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
-                DBG("Error during status notification");
-                return;
-        }
+	if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
+		DBG("Error during status notification");
+		return;
+	}
 
 	ofono_netreg_status_notify(netreg, status, lac, ci, tech);
 }
 
-static void ril_network_state_change(struct ril_msg *message, gpointer user_data)
+static void ril_network_state_change(struct ril_msg *message,
+		gpointer user_data)
 {
 	struct ofono_netreg *netreg = user_data;
 	struct netreg_data *nd = ofono_netreg_get_data(netreg);
@@ -364,6 +372,7 @@ static void ril_cops_list_cb(struct ril_msg *message, gpointer user_data)
 
 	cb(&error, noperators, list, cbd->data);
 
+	g_free(list);
 	return;
 
 error:
@@ -405,7 +414,8 @@ static void ril_register_cb(struct ril_msg *message, gpointer user_data)
 		g_ril_print_response_no_args(nd->ril, message);
 
 	} else {
-		ofono_error("registration failed");
+		ofono_error("registration failed, ril result %d",
+				message->error);
 		decode_ril_error(&error, "FAIL");
 	}
 
@@ -421,6 +431,8 @@ static void ril_register_auto(struct ofono_netreg *netreg,
 	int ret;
 	cbd->user = nd;
 
+	ofono_info("nw select automatic");
+
 	ret = g_ril_send(nd->ril, request,
 				NULL, 0, ril_register_cb, cbd, g_free);
 
@@ -444,6 +456,8 @@ static void ril_register_manual(struct ofono_netreg *netreg,
 	int request = RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL;
 	int ret;
 
+	ofono_info("nw select manual: %s%s", mcc, mnc);
+
 	/* add *netreg_data to callback */
 	cbd->user = nd;
 
@@ -573,6 +587,17 @@ error:
 	ofono_error("Unable to notify ofono about nitz");
 }
 
+gboolean check_if_ok_to_attach()
+{
+	int status = NETWORK_REGISTRATION_STATUS_SEARCHING;
+	status = ofono_netreg_get_status(current_netreg);
+	if (status == NETWORK_REGISTRATION_STATUS_SEARCHING
+		|| status == NETWORK_REGISTRATION_STATUS_ROAMING
+		|| status == NETWORK_REGISTRATION_STATUS_REGISTERED)
+		return TRUE;
+	return FALSE;
+}
+
 gint check_if_really_roaming(gint status)
 {
 	const char *net_mcc = ofono_netreg_get_mcc(current_netreg);
@@ -580,14 +605,20 @@ gint check_if_really_roaming(gint status)
 	struct sim_spdi *spdi = ofono_netreg_get_spdi(current_netreg);
 
 	if (spdi && net_mcc && net_mnc) {
-		if (sim_spdi_lookup(spdi, net_mcc, net_mnc))
+		if (sim_spdi_lookup(spdi, net_mcc, net_mnc)) {
+			ofono_info("voice reg: not roaming based on spdi");
 			return NETWORK_REGISTRATION_STATUS_REGISTERED;
-		else
+		} else
 			return status;
 	} else
 		return status;
 }
 
+gint get_current_network_status()
+{
+	return ofono_netreg_get_status(current_netreg);
+}
+
 static gboolean ril_delayed_register(gpointer user_data)
 {
 	struct ofono_netreg *netreg = user_data;
@@ -632,6 +663,7 @@ static int ril_netreg_probe(struct ofono_netreg *netreg, unsigned int vendor,
 	nd->time.year = -1;
 	nd->time.dst = 0;
 	nd->time.utcoff = 0;
+	nd->corestatus = -1;
 	current_netreg = netreg;
 
 	ofono_netreg_set_data(netreg, nd);
@@ -658,6 +690,7 @@ static void ril_netreg_remove(struct ofono_netreg *netreg)
 		g_source_remove(nd->nitz_timeout);
 
 	ofono_netreg_set_data(netreg, NULL);
+	current_netreg = NULL;
 
 	if (nd->timer_id > 0)
 		g_source_remove(nd->timer_id);

ofono/drivers/rilmodem/oemraw-messages.c

@@ -38,14 +38,18 @@
 struct oem_raw_data {
 	GRil *ril;
 	unsigned int vendor;
+	guint timer_id;
 };
 
 static gboolean ril_oemraw_delayed_register(gpointer user_data)
 {
 	struct ofono_oem_raw *raw = user_data;
+	struct oem_raw_data *od = ofono_oem_raw_get_data(raw);
 
 	DBG("");
 
+	od->timer_id = 0;
+
 	ofono_oem_raw_dbus_register(raw);
 	return FALSE; /* This makes the timeout a single-shot */
 }
@@ -64,7 +68,8 @@ static int ril_oemraw_probe(struct ofono_oem_raw *raw, unsigned int vendor,
 	od->vendor = vendor;
 	ofono_oem_raw_set_data(raw, od);
 
-	g_timeout_add_seconds(1, ril_oemraw_delayed_register, raw);
+	od->timer_id = g_timeout_add_seconds(1, ril_oemraw_delayed_register,
+									raw);
 
 	return 0;
 }
@@ -79,6 +84,9 @@ static void ril_oemraw_remove(struct ofono_oem_raw *raw)
 
 	ofono_oem_raw_set_data(raw, NULL);
 
+	if (od->timer_id)
+		g_source_remove(od->timer_id);
+
 	g_ril_unref(od->ril);
 	g_free(od);
 }

ofono/drivers/rilmodem/phonebook.c

@@ -6,7 +6,6 @@
  *  Copyright (C) ST-Ericsson SA 2010.
  *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
  *  Copyright (C) 2013 Jolla Ltd
- *  Contact: Jussi Kangas <jussi.kangas@tieto.com>
  *
  *  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
@@ -162,11 +161,18 @@ void handle_adn(size_t len, char *name, const unsigned char *msg,
 		char *number, struct pb_file_info *next_file,
 		struct pb_data *pbd)
 {
-	const uint8_t name_length = len - 14;
-	const uint8_t number_start = name_length;
+	uint8_t name_length;
+	uint8_t number_start;
 	uint8_t number_length = 0;
 	uint8_t extension_record = UNUSED;
 	uint8_t i, prefix;
+
+	if (len < 14)
+		return;
+
+	name_length = len - 14;
+	number_start = name_length;
+
 	name = sim_string_to_utf8(msg, name_length);
 	/* Length contains also TON&NPI */
 	number_length = msg[number_start];
@@ -256,15 +262,19 @@ void handle_adn(size_t len, char *name, const unsigned char *msg,
 	}
 }
 
-void handle_sne(size_t len,
-				const unsigned char *msg,
-				char *sne)
+void handle_sne(size_t len, const unsigned char *msg, char *sne)
 {
-	const uint8_t sne_length = len - 2;
-	uint8_t phonebook_entry_nbr = msg[len - 1];
+	uint8_t sne_length;
+	uint8_t phonebook_entry_nbr;
 
 	DBG("SNE");
 
+	if (len < 2)
+		return;
+
+	sne_length = len - 2;
+	phonebook_entry_nbr = msg[len - 1];
+
 	sne = sim_string_to_utf8(msg, sne_length);
 
 	if (sne) {
@@ -282,37 +292,40 @@ void handle_sne(size_t len,
 				list_entry->data;
 
 			if (entry) {
-				/* If one already exists,
-						delete it */
-				if (entry->sne)
-					g_free(entry->sne);
-
 				DBG("Adding SNE to entry %d",
 					phonebook_entry_nbr);
 				DBG("name %s", entry->name);
 
+				g_free(entry->sne);
 				entry->sne = sne;
-			} else {
-				g_free(sne);
+				return;
 			}
 		}
+
+		g_free(sne);
 	}
 }
 
-void handle_anr(size_t len,
-				const unsigned char *msg,
-				char *anr,
-				struct pb_file_info *next_file,
-				struct pb_data *pbd)
+void handle_anr(size_t len,const unsigned char *msg,char *anr,
+			struct pb_file_info *next_file, struct pb_data *pbd)
 {
 	uint8_t number_length = 0;
 	uint8_t extension_record = UNUSED;
 	uint8_t aas_record = UNUSED;
 	uint8_t i, prefix;
-	uint8_t phonebook_entry_nbr = msg[len - 1];
+	uint8_t phonebook_entry_nbr;
 	GSList *list_entry;
 
 	DBG("ANR");
+
+	if (!msg)
+		return;
+
+	if (len < 1)
+		return;
+
+	phonebook_entry_nbr = msg[len - 1];
+
 	if (msg[0] == UNUSED)
 		return;
 
@@ -328,7 +341,7 @@ void handle_anr(size_t len,
 			prefix = 0;
 
 			if ((msg[2] & TON_MASK) ==
-			    TON_INTERNATIONAL) {
+				TON_INTERNATIONAL) {
 				anr[0] = '+';
 				prefix = 1;
 			}
@@ -398,11 +411,18 @@ void handle_anr(size_t len,
 	}
 }
 
-void handle_email(size_t len,
-			const unsigned char *msg,
-			char *email)
+void handle_email(size_t len, const unsigned char *msg, char *email)
 {
-	uint8_t phonebook_entry_nbr = msg[len - 1];
+	uint8_t phonebook_entry_nbr;
+
+	if (!msg)
+		return;
+
+	if (len < 1)
+		return;
+
+	phonebook_entry_nbr = msg[len - 1];
+
 	email = sim_string_to_utf8(msg, len - 2);
 
 	/* GSlist nth counts from 0, PB entries from 1 */
@@ -434,13 +454,13 @@ void handle_email(size_t len,
 	}
 }
 
-void handle_ext1(struct pb_data *pbd,
-			const unsigned char *msg,
-			char *ext_number,
-			struct pb_file_info *next_file)
+void handle_ext1(struct pb_data *pbd, const unsigned char *msg,
+			char *ext_number, struct pb_file_info *next_file)
 {
 	uint8_t number_length, i, next_extension_record;
 
+	if (!msg)
+		return;
 
 	number_length = msg[1];
 
@@ -494,7 +514,7 @@ void handle_ext1(struct pb_data *pbd,
 						list_entry->data;
 				if (entry) {
 					strcat(entry->anr,
-				       ext_number);
+						ext_number);
 			}
 		}
 	}
@@ -610,8 +630,10 @@ static void pb_adn_sim_data_cb(const struct ofono_error *error,
 	file_info = cbd_outer->user;
 	cbd = cbd_outer->data;
 
-	if (!cbd)
+	if (!cbd) {
+		g_free(cbd_outer);
 		return;
+		}
 
 	pb = cbd->user;
 	cb = cbd->cb;
@@ -694,8 +716,10 @@ static void pb_adn_sim_data_cb(const struct ofono_error *error,
 			g_slist_free(phonebook_entry_start);
 			g_slist_free(pb_files);
 			g_free(cbd_outer);
+			void *pb = cbd->data;
+			g_free(cbd);
 			DBG("Finally all PB data read");
-			CALLBACK_WITH_SUCCESS(cb, cbd->data);
+			CALLBACK_WITH_SUCCESS(cb, pb);
 			return;
 		}
 	}
@@ -720,9 +744,6 @@ static void pb_adn_sim_info_cb(const struct ofono_error *error,
 	if (!cbd)
 		goto error;
 
-	pb = cbd->user;
-	cb = cbd->cb;
-	pbd = ofono_phonebook_get_data(pb);
 	file_info = NULL;
 
 	if (!pbd)
@@ -765,8 +786,12 @@ static void pb_adn_sim_info_cb(const struct ofono_error *error,
 	return;
 error:
 
-	if (cb && cbd)
-		CALLBACK_WITH_FAILURE(cb, cbd->data);
+	if (cbd){
+		void *pb = cbd->data;
+		g_free(cbd);
+		if(cb)
+			CALLBACK_WITH_FAILURE(cb, pb);
+	}
 }
 
 static gboolean is_reading_required(uint8_t file_type)
@@ -799,9 +824,28 @@ static void pb_content_data_cb(const struct ofono_error *error,
 	if (extension_file_info)
 		file_info = decode_read_response(extension_file_info, sdata,
 						 length, pb);
-	else
+	else {
+	/*
+	 * These checks are crash hacks.
+	 * AFAIK there's a possibility that we end up here and pb_next is NULL
+	 * in case remove has been called while phonebook reading is in
+	 * process. If you find better solution to this issue feel free to
+	 * change this.
+	 */
+		if (pb_next == NULL) {
+			ofono_error("phonebook reading failed");
+			if (cbd){
+				void *pb = cbd->data;
+				g_free(cbd);
+				if(cb && pbd)
+					CALLBACK_WITH_FAILURE(cb, pb);
+				}
+			return;
+		}
+
 		file_info =
 			decode_read_response(pb_next->data, sdata, length, pb);
+	}
 
 	if (file_info) {
 		DBG("Reading extension file %04X, record %d, structure %d",
@@ -818,7 +862,7 @@ static void pb_content_data_cb(const struct ofono_error *error,
 		file_info = pb_next->data;
 
 		if (((file_info->structure ==
-		      OFONO_SIM_FILE_STRUCTURE_FIXED) ||
+			OFONO_SIM_FILE_STRUCTURE_FIXED) ||
 			(file_info->structure ==
 			 OFONO_SIM_FILE_STRUCTURE_CYCLIC))
 			&& (file_info->record <
@@ -855,7 +899,7 @@ static void pb_content_data_cb(const struct ofono_error *error,
 				DBG("All data requested, start vCard creation");
 				while (list_entry) {
 					struct phonebook_entry *entry =
-					    list_entry->data;
+							list_entry->data;
 
 					if (entry) {
 						DBG("vCard:\nname=%s\n",
@@ -892,8 +936,10 @@ static void pb_content_data_cb(const struct ofono_error *error,
 
 				g_slist_free(phonebook_entry_start);
 				g_slist_free(pb_files);
+				void *pb = cbd->data;
+				g_free(cbd);
 				DBG("Finally all PB data read");
-				CALLBACK_WITH_SUCCESS(cb, cbd->data);
+				CALLBACK_WITH_SUCCESS(cb, pb);
 				return;
 			}
 
@@ -958,8 +1004,12 @@ static void pb_content_data_read(struct pb_data *pbd,
 	return;
 error:
 
-	if (cb && cbd)
-		CALLBACK_WITH_FAILURE(cb, cbd->data);
+	if (cbd){
+		void *pb = cbd->data;
+		g_free(cbd);
+		if(cb)
+			CALLBACK_WITH_FAILURE(cb, pb);
+	}
 
 out:
 	DBG("Exiting");
@@ -1032,9 +1082,11 @@ static void pb_content_info_cb(const struct ofono_error *error,
 	return;
 error:
 
-	if (cb && cbd) {
-		DBG("Error cbd=%p, pbd=%p, file_info=%p", cbd, pbd, file_info);
-		CALLBACK_WITH_FAILURE(cb, cbd->data);
+	if (cbd){
+		void *pb = cbd->data;
+		g_free(cbd);
+		if(cb)
+			CALLBACK_WITH_FAILURE(cb, pb);
 	}
 }
 
@@ -1107,15 +1159,27 @@ static void pb_reference_data_cb(const struct ofono_error *error,
 			pbd->pb_reference_file_info.record_length)) {
 		pbd->pb_reference_file_info.record++;
 		DBG("Next EFpbr record %d", pbd->pb_reference_file_info.record);
-		pbd->sim_driver->read_file_linear(get_sim(),
-						pbd->pb_reference_file_info.
-						file_id,
-						pbd->pb_reference_file_info.
-						record,
-						pbd->pb_reference_file_info.
-						record_length,
-						NULL, 0,
-						pb_reference_data_cb, cbd);
+		if (RIL_APPTYPE_SIM == ril_get_app_type()) {
+			pbd->sim_driver->read_file_linear(get_sim(),
+					pbd->pb_reference_file_info.
+					file_id,
+					pbd->pb_reference_file_info.
+					record,
+					pbd->pb_reference_file_info.
+					record_length,
+					sim_path, sizeof(sim_path),
+					pb_reference_data_cb, cbd);
+		} else {
+			pbd->sim_driver->read_file_linear(get_sim(),
+					pbd->pb_reference_file_info.
+					file_id,
+					pbd->pb_reference_file_info.
+					record,
+					pbd->pb_reference_file_info.
+					record_length,
+					usim_path, sizeof(usim_path),
+					pb_reference_data_cb, cbd);
+		}
 	} else {
 		struct pb_file_info *file_info;
 		DBG("All EFpbr records read");
@@ -1137,8 +1201,12 @@ static void pb_reference_data_cb(const struct ofono_error *error,
 	return;
 error:
 
-	if (cb && cbd)
-		CALLBACK_WITH_FAILURE(cb, cbd->data);
+	if (cbd){
+		void *pb = cbd->data;
+		g_free(cbd);
+		if(cb)
+			CALLBACK_WITH_FAILURE(cb, pb);
+	}
 }
 
 static void pb_reference_info_cb(const struct ofono_error *error,
@@ -1189,8 +1257,12 @@ static void pb_reference_info_cb(const struct ofono_error *error,
 					pb_reference_data_cb, cbd);
 	return;
 error:
-	if (cb && cbd)
-		CALLBACK_WITH_FAILURE(cb, cbd->data);
+	if (cbd){
+		void *pb = cbd->data;
+		g_free(cbd);
+		if(cb)
+			CALLBACK_WITH_FAILURE(cb, pb);
+	}
 }
 
 static void ril_export_entries(struct ofono_phonebook *pb,
@@ -1229,10 +1301,12 @@ static void ril_export_entries(struct ofono_phonebook *pb,
 
 error:
 
-	if (cb && cbd)
-		CALLBACK_WITH_FAILURE(cb, cbd->data);
-
-	g_free(cbd);
+	if (cbd){
+		void *pb = cbd->data;
+		g_free(cbd);
+		if(cb)
+			CALLBACK_WITH_FAILURE(cb, pb);
+	}
 }
 
 static gboolean ril_delayed_register(gpointer user_data)
@@ -1280,7 +1354,7 @@ static struct ofono_phonebook_driver driver = {
 	.name				= "rilmodem",
 	.probe				= ril_phonebook_probe,
 	.remove				= ril_phonebook_remove,
-	.export_entries		= ril_export_entries
+	.export_entries			= ril_export_entries
 };
 
 void ril_phonebook_init(void)

ofono/drivers/rilmodem/radio-settings.c

@@ -35,6 +35,7 @@
 #include <ofono/log.h>
 #include <ofono/modem.h>
 #include <ofono/radio-settings.h>
+#include <ofono/sim.h>
 
 #include "gril.h"
 #include "grilutil.h"
@@ -74,7 +75,7 @@ static void ril_set_rat_mode(struct ofono_radio_settings *rs,
 	int pref = rd->ratmode;
 	int ret = 0;
 
-	ofono_info("setting rat mode");
+	ofono_info("rat mode set %d", mode);
 
 	parcel_init(&rilp);
 
@@ -115,6 +116,8 @@ static void ril_force_rat_mode(struct radio_data *rd, int pref)
 	if (pref == rd->ratmode)
 		return;
 
+	DBG("pref ril rat mode %d, ril current %d", pref, rd->ratmode);
+
 	parcel_init(&rilp);
 	parcel_w_int32(&rilp, 1);
 	parcel_w_int32(&rilp, rd->ratmode);
@@ -136,7 +139,7 @@ static void ril_rat_mode_cb(struct ril_msg *message, gpointer user_data)
 
 	if (message->error == RIL_E_SUCCESS) {
 		ril_util_init_parcel(message, &rilp);
-		/*first item in int[] is len so let's skip that*/
+		/* first item in int[] is len so let's skip that */
 		parcel_r_int32(&rilp);
 		pref = parcel_r_int32(&rilp);
 
@@ -166,6 +169,7 @@ static void ril_rat_mode_cb(struct ril_msg *message, gpointer user_data)
 		default:
 			break;
 		}
+		ofono_info("rat mode %d (ril %d)", mode, pref);
 		if (cb)
 			CALLBACK_WITH_SUCCESS(cb, mode, cbd->data);
 	} else {
@@ -200,11 +204,17 @@ static gboolean ril_get_net_config(struct radio_data *rsd)
 {
 	GKeyFile *keyfile;
 	GError *err = NULL;
-	char *path = RIL_CONFIG;
+	char *config_path = RIL_CONFIG_DIR;
 	char **alreadyset = NULL;
 	gboolean needsconfig = FALSE;
 	gboolean value = FALSE;
+	gboolean found = FALSE;
 	rsd->ratmode = PREF_NET_TYPE_GSM_WCDMA_AUTO;
+	GDir *config_dir;
+	const gchar *config_file;
+	gsize length;
+	gchar **codes = NULL;
+	int i;
 
 	/*
 	 * First we need to check should the LTE be on
@@ -215,15 +225,45 @@ static gboolean ril_get_net_config(struct radio_data *rsd)
 
 	g_key_file_set_list_separator(keyfile, ',');
 
-	if (g_key_file_load_from_file(keyfile, path, 0, &err)) {
+	config_dir = g_dir_open(config_path, 0, NULL);
+	while ((config_file = g_dir_read_name(config_dir)) != NULL) {
+		char *path = g_strconcat(RIL_CONFIG_DIR "/", config_file, NULL);
+		DBG("Rilconfig handling %s", path);
+		gboolean ok = g_key_file_load_from_file(keyfile, path, 0, &err);
+
+		g_free(path);
+		if (!ok) {
+			g_error_free(err);
+			DBG("Rilconfig file skipped");
+			continue;
+		}
+
 		if (g_key_file_has_group(keyfile, LTE_FLAG))
+			found = TRUE;
+		else if (g_key_file_has_group(keyfile, MCC_LIST)) {
+			codes = g_key_file_get_string_list(keyfile, MCC_LIST,
+						MCC_KEY, &length, NULL);
+			if (codes) {
+				for (i = 0; codes[i]; i++) {
+					if (g_str_equal(codes[i],
+						ofono_sim_get_mcc(get_sim()))
+							== TRUE) {
+						found = TRUE;
+						break;
+					}
+				}
+				g_strfreev(codes);
+			}
+		}
+
+		if (found) {
 			rsd->ratmode = PREF_NET_TYPE_LTE_GSM_WCDMA;
-	} else {
-		g_error_free(err);
-		needsconfig = TRUE;
+			break;
+		}
 	}
 
 	g_key_file_free(keyfile);
+	g_dir_close(config_dir);
 
 	/* Then we need to check if it already set */
 
@@ -250,6 +290,7 @@ static gboolean ril_get_net_config(struct radio_data *rsd)
 
 	storage_close(NULL, RIL_STORE, keyfile, TRUE);
 
+	DBG("needsconfig %d, rat mode %d", needsconfig, rsd->ratmode);
 	return needsconfig;
 }
 

ofono/drivers/rilmodem/rilmodem.c

@@ -53,8 +53,10 @@ static int rilmodem_init(void)
 	ril_ussd_init();
 	ril_call_settings_init();
 	ril_call_forwarding_init();
+	ril_call_barring_init();
 	ril_cbs_init();
 	ril_oemraw_init();
+	ril_stk_init();
 
 	return 0;
 }
@@ -76,8 +78,10 @@ static void rilmodem_exit(void)
 	ril_ussd_exit();
 	ril_call_settings_exit();
 	ril_call_forwarding_exit();
+	ril_call_barring_exit();
 	ril_cbs_exit();
 	ril_oemraw_exit();
+	ril_stk_exit();
 }
 
 OFONO_PLUGIN_DEFINE(rilmodem, "RIL modem driver", VERSION,

ofono/drivers/rilmodem/rilmodem.h

@@ -28,9 +28,14 @@
 /* Shared constants */
 #define EF_STATUS_INVALIDATED 0
 #define EF_STATUS_VALID 1
-#define RIL_CONFIG "/etc/ofono/ril_subscription.conf"
+#define RIL_HW_CONFIG "/etc/ofono/ril_subscription.conf"
+#define RIL_CONFIG_DIR "/etc/ofono/"
 #define RIL_STORE "rilmodem"
 #define LTE_FLAG "4gOn"
+#define MCC_LIST "MCC-whitelist"
+#define MCC_KEY "Countries"
+#define UI_LANG "/var/lib/environment/nemo/locale.conf"
+#define CFG_LANG "LANG="
 
 extern void ril_devinfo_init(void);
 extern void ril_devinfo_exit(void);
@@ -68,6 +73,9 @@ extern void ril_call_settings_exit(void);
 extern void ril_call_forwarding_init(void);
 extern void ril_call_forwarding_exit(void);
 
+extern void ril_call_barring_init(void);
+extern void ril_call_barring_exit(void);
+
 extern void ril_cbs_init(void);
 extern void ril_cbs_exit(void);
 
@@ -76,3 +84,7 @@ extern void ril_phonebook_exit(void);
 
 extern void ril_oemraw_init(void);
 extern void ril_oemraw_exit(void);
+
+extern void ril_stk_init(void);
+extern void ril_stk_exit(void);
+

ofono/drivers/rilmodem/rilutil.c

@@ -375,7 +375,14 @@ gboolean ril_util_parse_sim_status(GRil *gril,
 	 * Do we just make a style-guide exception for PrintBuf operations?
 	 */
 	g_ril_append_print_buf(gril,
-				"(card_state=%d,universal_pin_state=%d,gsm_umts_index=%d,cdma_index=%d,ims_index=%d, ",
+				"card_state=%d,universal_pin_state=%d,gsm_umts_index=%d,cdma_index=%d,ims_index=%d, ",
+				status->card_state,
+				status->pin_state,
+				status->gsm_umts_index,
+				status->cdma_index,
+				status->ims_index);
+
+	DBG("card_state=%d, universal_pin_state=%d, gsm_umts_index=%d, cdma_index=%d, ims_index=%d",
 				status->card_state,
 				status->pin_state,
 				status->gsm_umts_index,
@@ -387,13 +394,13 @@ gboolean ril_util_parse_sim_status(GRil *gril,
 	else
 		goto done;
 
+	DBG("sim num_apps: %d", status->num_apps);
 	if (status->num_apps > MAX_UICC_APPS) {
 		ofono_error("SIM error; too many apps: %d", status->num_apps);
 		status->num_apps = MAX_UICC_APPS;
 	}
 
 	for (i = 0; i < status->num_apps; i++) {
-		DBG("processing app[%d]", i);
 		apps[i] = g_try_new0(struct sim_app, 1);
 		if (apps[i] == NULL) {
 			ofono_error("Can't allocate app_data");
@@ -402,13 +409,25 @@ gboolean ril_util_parse_sim_status(GRil *gril,
 
 		apps[i]->app_type = parcel_r_int32(&rilp);
 		apps[i]->app_state = parcel_r_int32(&rilp);
+
+		/*
+		 * Consider RIL_APPSTATE_ILLEGAL also READY. Even if app state
+		 * is  RIL_APPSTATE_ILLEGAL (-1), ICC operations must be
+		 * permitted. Network access requests will anyway be rejected
+		 * and ME will be in limited service.
+		 */
+		if (apps[i]->app_state == RIL_APPSTATE_ILLEGAL) {
+			DBG("RIL_APPSTATE_ILLEGAL => RIL_APPSTATE_READY");
+			apps[i]->app_state = RIL_APPSTATE_READY;
+		}
+
 		apps[i]->perso_substate = parcel_r_int32(&rilp);
 
 		/* TODO: we need a way to instruct parcel to skip
 		 * a string, without allocating memory...
 		 */
-		apps[i]->aid_str = parcel_r_string(&rilp); /* application ID (AID) */
-		apps[i]->app_str = parcel_r_string(&rilp); /* application label */
+		apps[i]->aid_str = parcel_r_string(&rilp); /* app ID (AID) */
+		apps[i]->app_str = parcel_r_string(&rilp); /* app label */
 
 		apps[i]->pin_replaced = parcel_r_int32(&rilp);
 		apps[i]->pin1_state = parcel_r_int32(&rilp);
@@ -425,6 +444,16 @@ gboolean ril_util_parse_sim_status(GRil *gril,
 					apps[i]->pin_replaced,
 					apps[i]->pin1_state,
 					apps[i]->pin2_state);
+
+		DBG("app[%d]: type=%d, state=%d, perso_substate=%d, aid_ptr=%s, app_label_ptr=%s, pin1_replaced=%d, pin1=%d, pin2=%d",
+					i, apps[i]->app_type,
+					apps[i]->app_state,
+					apps[i]->perso_substate,
+					apps[i]->aid_str,
+					apps[i]->app_str,
+					apps[i]->pin_replaced,
+					apps[i]->pin1_state,
+					apps[i]->pin2_state);
 	}
 
 done:
@@ -459,7 +488,8 @@ gboolean ril_util_parse_reg(GRil *gril,
 	 *   >= 4 for VOICE_REG reply
 	 *   >= 5 for DATA_REG reply
 	 */
-	if ((tmp = parcel_r_int32(&rilp)) < 4) {
+	tmp = parcel_r_int32(&rilp);
+	if (tmp < 4) {
 		DBG("Size of response array is too small: %d", tmp);
 		goto error;
 	}
@@ -482,10 +512,12 @@ gboolean ril_util_parse_reg(GRil *gril,
 	 * voice & data response.
 	 */
 	if (tmp--) {
-		sreason = parcel_r_string(&rilp);        /* TODO: different use for CDMA */
+		/* TODO: different use for CDMA */
+		sreason = parcel_r_string(&rilp);
 
 		if (tmp--) {
-			smax = parcel_r_string(&rilp);           /* TODO: different use for CDMA */
+			/* TODO: different use for CDMA */
+			smax = parcel_r_string(&rilp);
 
 			if (smax && max_calls)
 				*max_calls = atoi(smax);
@@ -518,7 +550,7 @@ gboolean ril_util_parse_reg(GRil *gril,
 
 	if (tech) {
 		if (stech) {
-			switch(atoi(stech)) {
+			switch (atoi(stech)) {
 			case RADIO_TECH_UNKNOWN:
 				*tech = -1;
 				break;
@@ -591,8 +623,10 @@ gint ril_util_parse_sms_response(GRil *gril, struct ril_msg *message)
 	 */
 	mr = parcel_r_int32(&rilp);
 	ack_pdu = parcel_r_string(&rilp);
-	error = parcel_r_int32(&rilp);
 
+	/* error: 3GPP 27.005, 3.2.5, -1 if unknown or not applicable */
+	error = parcel_r_int32(&rilp);
+	DBG("sms msg ref: %d, error: %d, ack_pdu: %s", mr, error, ack_pdu);
 
 	g_ril_append_print_buf(gril, "{%d,%s,%d}",
 				mr, ack_pdu, error);
@@ -659,7 +693,8 @@ gint ril_util_get_signal(GRil *gril, struct ril_msg *message)
 	return -1;
 }
 
-void ril_util_free_sim_apps(struct sim_app **apps, guint num_apps) {
+void ril_util_free_sim_apps(struct sim_app **apps, guint num_apps)
+{
 	guint i;
 
 	for (i = 0; i < num_apps; i++) {

ofono/drivers/rilmodem/rilutil.h

@@ -62,29 +62,6 @@ enum at_util_charset {
 	RIL_UTIL_CHARSET_8859_H =	0x10000,
 };
 
-/* TODO: consider moving these to ril_constants.h */
-enum app_state {
-	APPSTATE_UNKNOWN,
-	APPSTATE_DETECTED,
-	APPSTATE_PIN,
-	APPSTATE_PUK,
-	APPSTATE_SUBSCRIPTION_PERSO,
-	APPSTATE_READY,
-};
-
-enum perso_state {
-	PERSOSUBSTATE_SIM_NETWORK = 3,
-	PERSOSUBSTATE_SIM_NETWORK_SUBSET,
-	PERSOSUBSTATE_SIM_CORPORATE,
-	PERSOSUBSTATE_SIM_SERVICE_PROVIDER,
-	PERSOSUBSTATE_SIM_SIM,
-	PERSOSUBSTATE_SIM_NETWORK_PUK,
-	PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK,
-	PERSOSUBSTATE_SIM_CORPORATE_PUK,
-	PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK,
-	PERSOSUBSTATE_SIM_SIM_PUK,
-};
-
 #define MAX_UICC_APPS 16
 
 struct sim_status {
@@ -146,6 +123,12 @@ struct ofono_sim *get_sim();
 
 gint check_if_really_roaming(gint status);
 
+gboolean ril_roaming_allowed();
+
+gboolean check_if_ok_to_attach();
+
+gint get_current_network_status();
+
 void ril_util_free_sim_apps(struct sim_app **apps, guint num_apps);
 
 struct cb_data {
@@ -170,7 +153,7 @@ static inline struct cb_data *cb_data_new2(void *user, void *cb,
 {
 	struct cb_data *ret;
 
-	ret = g_try_new0(struct cb_data, 1);
+	ret = g_new0(struct cb_data, 1);
 
 	if (ret) {
 		ret->cb = cb;
@@ -193,7 +176,7 @@ static inline int ril_util_convert_signal_strength(int strength)
 	return result;
 }
 
-#define DECLARE_FAILURE(e) 			\
+#define DECLARE_FAILURE(e)			\
 	struct ofono_error e;			\
 	e.type = OFONO_ERROR_TYPE_FAILURE;	\
 	e.error = 0				\

ofono/drivers/rilmodem/sim.c

@@ -4,6 +4,7 @@
  *
  *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
  *  Copyright (C) 2013 Canonical, Ltd. All rights reserved.
+ *  Copyright (C) 2014 Jolla 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
@@ -42,6 +43,7 @@
 #include "util.h"
 
 #include "gril.h"
+#include "grilrequest.h"
 #include "grilutil.h"
 #include "parcel.h"
 #include "ril_constants.h"
@@ -74,10 +76,6 @@
 #define ENTER_SIM_PUK_PARAMS 3
 #define CHANGE_SIM_PIN_PARAMS 3
 
-/* RIL_FACILITY_LOCK parameters */
-#define RIL_FACILITY_UNLOCK "0"
-#define RIL_FACILITY_LOCK "1"
-
 /* Current SIM */
 static struct ofono_sim *current_sim;
 /* Current active app */
@@ -100,12 +98,12 @@ struct sim_data {
 	guint app_type;
 	gchar *app_str;
 	guint app_index;
-	gboolean sim_registered;
 	enum ofono_sim_password_type passwd_type;
 	int retries[OFONO_SIM_PASSWORD_INVALID];
 	enum ofono_sim_password_type passwd_state;
-	guint card_state;
 	guint idle_id;
+	gboolean initialized;
+	gboolean removed;
 };
 
 static void ril_pin_change_state_cb(struct ril_msg *message,
@@ -129,7 +127,8 @@ static void set_path(struct sim_data *sd, struct parcel *rilp,
 	} else if (sd->app_type == RIL_APPTYPE_SIM) {
 		len = sim_ef_db_get_path_2g(fileid, db_path);
 	} else {
-		ofono_error("Unsupported app_type: 0%x", sd->app_type);
+		ofono_error("%s Unsupported app_type: 0%x", __func__,
+				sd->app_type);
 	}
 
 	if (len > 0) {
@@ -183,6 +182,15 @@ static void ril_file_info_cb(struct ril_msg *message, gpointer user_data)
 
 	DBG("");
 
+	/* In case sim card has been removed prior to this callback has been
+	 * called we must not call the core call back method as otherwise the
+	 * core will crash.
+	 */
+	if (sd->removed == TRUE) {
+		ofono_error("%s RIL_CARDSTATE_ABSENT", __func__);
+		return;
+	}
+
 	if (message->error == RIL_E_SUCCESS) {
 		decode_ril_error(&error, "OK");
 	} else {
@@ -197,14 +205,15 @@ static void ril_file_info_cb(struct ril_msg *message, gpointer user_data)
 						&sw1,
 						&sw2,
 						&response_len)) == NULL) {
-		ofono_error("Can't parse SIM IO response from RILD");
+		ofono_error("%s Can't parse SIM IO response", __func__);
 		decode_ril_error(&error, "FAIL");
 		goto error;
 	}
 
 	if ((sw1 != 0x90 && sw1 != 0x91 && sw1 != 0x92 && sw1 != 0x9f) ||
 		(sw1 == 0x90 && sw2 != 0x00)) {
-		ofono_error("invalid values: sw1: %02x sw2: %02x", sw1, sw2);
+		ofono_error("%s invalid values: sw1: %02x sw2: %02x", __func__,
+				sw1, sw2);
 		memset(&error, 0, sizeof(error));
 
 		/* TODO: fix decode_ril_error to take type & error */
@@ -217,15 +226,17 @@ static void ril_file_info_cb(struct ril_msg *message, gpointer user_data)
 
 	if (response_len) {
 		if (response[0] == 0x62) {
-			ok = sim_parse_3g_get_response(response, response_len,
-							&flen, &rlen, &str, access, NULL);
+			ok = sim_parse_3g_get_response(
+				response, response_len,
+				&flen, &rlen, &str, access, NULL);
 		} else
-			ok = sim_parse_2g_get_response(response, response_len,
-							&flen, &rlen, &str, access, &file_status);
+			ok = sim_parse_2g_get_response(
+				response, response_len,
+				&flen, &rlen, &str, access, &file_status);
 	}
 
 	if (!ok) {
-		ofono_error("parse response failed");
+		ofono_error("%s parse response failed", __func__);
 		decode_ril_error(&error, "FAIL");
 		goto error;
 	}
@@ -240,7 +251,8 @@ error:
 }
 
 static void ril_sim_read_info(struct ofono_sim *sim, int fileid,
-				const unsigned char *path, unsigned int path_len,
+				const unsigned char *path,
+				unsigned int path_len,
 				ofono_sim_file_info_cb_t cb,
 				void *data)
 {
@@ -314,8 +326,8 @@ static void ril_file_io_cb(struct ril_msg *message, gpointer user_data)
 	if (message->error == RIL_E_SUCCESS) {
 		decode_ril_error(&error, "OK");
 	} else {
-		ofono_error("RILD reply failure: %s",
-			    ril_error_to_string(message->error));
+		ofono_error("%s RILD reply failure: %s", __func__,
+				ril_error_to_string(message->error));
 		goto error;
 	}
 
@@ -325,7 +337,7 @@ static void ril_file_io_cb(struct ril_msg *message, gpointer user_data)
 						&sw1,
 						&sw2,
 						&response_len)) == NULL) {
-		ofono_error("Error parsing IO response");
+		ofono_error("%s Error parsing IO response", __func__);
 		goto error;
 	}
 
@@ -340,7 +352,8 @@ error:
 
 static void ril_sim_read_binary(struct ofono_sim *sim, int fileid,
 				int start, int length,
-				const unsigned char *path, unsigned int path_len,
+				const unsigned char *path,
+				unsigned int path_len,
 				ofono_sim_read_cb_t cb, void *data)
 {
 	struct sim_data *sd = ofono_sim_get_data(sim);
@@ -393,7 +406,8 @@ static void ril_sim_read_binary(struct ofono_sim *sim, int fileid,
 
 static void ril_sim_read_record(struct ofono_sim *sim, int fileid,
 				int record, int length,
-				const unsigned char *path, unsigned int path_len,
+				const unsigned char *path,
+				unsigned int path_len,
 				ofono_sim_read_cb_t cb, void *data)
 {
 	struct sim_data *sd = ofono_sim_get_data(sim);
@@ -457,7 +471,7 @@ static void ril_imsi_cb(struct ril_msg *message, gpointer user_data)
 		DBG("GET IMSI reply - OK");
 		decode_ril_error(&error, "OK");
 	} else {
-		ofono_error("Reply failure: %s",
+		ofono_error("%s Reply failure: %s", __func__,
 			    ril_error_to_string(message->error));
 		decode_ril_error(&error, "FAIL");
 		cb(&error, NULL, cbd->data);
@@ -506,88 +520,58 @@ static void ril_read_imsi(struct ofono_sim *sim, ofono_sim_imsi_cb_t cb,
 	}
 }
 
-void set_pin_lock_state(struct ofono_sim *sim,struct sim_app *app)
-{
-	DBG("pin1:%u,pin2:%u",app->pin1_state,app->pin2_state);
-	/* 
-	 * Updates only pin and pin2 state. Other locks are not dealt here. For
-	 * that a RIL_REQUEST_QUERY_FACILITY_LOCK request should be used.
-	 */
-	switch (app->pin1_state) {
-	case RIL_PINSTATE_ENABLED_NOT_VERIFIED:
-	case RIL_PINSTATE_ENABLED_VERIFIED:
-	case RIL_PINSTATE_ENABLED_BLOCKED:
-	case RIL_PINSTATE_ENABLED_PERM_BLOCKED:
-		ofono_set_pin_lock_state(sim,OFONO_SIM_PASSWORD_SIM_PIN,TRUE);
-		break;
-	case RIL_PINSTATE_DISABLED:
-		ofono_set_pin_lock_state(sim,OFONO_SIM_PASSWORD_SIM_PIN,FALSE);
-		break;
-	default:
-		break;
-	}
-	switch (app->pin2_state) {
-	case RIL_PINSTATE_ENABLED_NOT_VERIFIED:
-	case RIL_PINSTATE_ENABLED_VERIFIED:
-	case RIL_PINSTATE_ENABLED_BLOCKED:
-	case RIL_PINSTATE_ENABLED_PERM_BLOCKED:
-		ofono_set_pin_lock_state(sim,OFONO_SIM_PASSWORD_SIM_PIN2,TRUE);
-		break;
-	case RIL_PINSTATE_DISABLED:
-		ofono_set_pin_lock_state(sim,OFONO_SIM_PASSWORD_SIM_PIN2,FALSE);
-		break;
-	default:
-		break;
-	}
-}
-
 static void configure_active_app(struct sim_data *sd,
 					struct sim_app *app,
 					guint index)
 {
 	sd->app_type = app->app_type;
+
+	g_free(sd->aid_str);
 	sd->aid_str = g_strdup(app->aid_str);
+
+	g_free(sd->app_str);
 	sd->app_str = g_strdup(app->app_str);
+
 	sd->app_index = index;
 
 	DBG("setting aid_str (AID) to: %s", sd->aid_str);
 	switch (app->app_state) {
-	case APPSTATE_PIN:
+	case RIL_APPSTATE_PIN:
 		sd->passwd_state = OFONO_SIM_PASSWORD_SIM_PIN;
 		break;
-	case APPSTATE_PUK:
+	case RIL_APPSTATE_PUK:
 		sd->passwd_state = OFONO_SIM_PASSWORD_SIM_PUK;
 		break;
-	case APPSTATE_SUBSCRIPTION_PERSO:
+	case RIL_APPSTATE_SUBSCRIPTION_PERSO:
 		switch (app->perso_substate) {
-		case PERSOSUBSTATE_SIM_NETWORK:
+		case RIL_PERSOSUBSTATE_SIM_NETWORK:
 			sd->passwd_state = OFONO_SIM_PASSWORD_PHNET_PIN;
 			break;
-		case PERSOSUBSTATE_SIM_NETWORK_SUBSET:
+		case RIL_PERSOSUBSTATE_SIM_NETWORK_SUBSET:
 			sd->passwd_state = OFONO_SIM_PASSWORD_PHNETSUB_PIN;
 			break;
-		case PERSOSUBSTATE_SIM_CORPORATE:
+		case RIL_PERSOSUBSTATE_SIM_CORPORATE:
 			sd->passwd_state = OFONO_SIM_PASSWORD_PHCORP_PIN;
 			break;
-		case PERSOSUBSTATE_SIM_SERVICE_PROVIDER:
+		case RIL_PERSOSUBSTATE_SIM_SERVICE_PROVIDER:
 			sd->passwd_state = OFONO_SIM_PASSWORD_PHSP_PIN;
 			break;
-		case PERSOSUBSTATE_SIM_SIM:
+		case RIL_PERSOSUBSTATE_SIM_SIM:
 			sd->passwd_state = OFONO_SIM_PASSWORD_PHSIM_PIN;
 			break;
-		case PERSOSUBSTATE_SIM_NETWORK_PUK:
+		case RIL_PERSOSUBSTATE_SIM_NETWORK_PUK:
 			sd->passwd_state = OFONO_SIM_PASSWORD_PHNET_PUK;
 			break;
-		case PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK:
+		case RIL_PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK:
 			sd->passwd_state = OFONO_SIM_PASSWORD_PHNETSUB_PUK;
 			break;
-		case PERSOSUBSTATE_SIM_CORPORATE_PUK:
+		case RIL_PERSOSUBSTATE_SIM_CORPORATE_PUK:
 			sd->passwd_state = OFONO_SIM_PASSWORD_PHCORP_PUK;
 			break;
-		case PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK:
+		case RIL_PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK:
 			sd->passwd_state = OFONO_SIM_PASSWORD_PHSP_PUK;
 			break;
-		case PERSOSUBSTATE_SIM_SIM_PUK:
+		case RIL_PERSOSUBSTATE_SIM_SIM_PUK:
 			sd->passwd_state = OFONO_SIM_PASSWORD_PHFSIM_PUK;
 			break;
 		default:
@@ -595,54 +579,124 @@ static void configure_active_app(struct sim_data *sd,
 			break;
 		};
 		break;
-	case APPSTATE_READY:
+	case RIL_APPSTATE_READY:
 		sd->passwd_state = OFONO_SIM_PASSWORD_NONE;
 		break;
-	case APPSTATE_UNKNOWN:
-	case APPSTATE_DETECTED:
+	case RIL_APPSTATE_UNKNOWN:
+	case RIL_APPSTATE_DETECTED:
 	default:
 		sd->passwd_state = OFONO_SIM_PASSWORD_INVALID;
 		break;
 	}
 }
 
+static void free_sim_state(struct sim_data *sd)
+{
+	guint i = 0;
+
+	sd->passwd_state = OFONO_SIM_PASSWORD_INVALID;
+
+	for (i = 0; i < OFONO_SIM_PASSWORD_INVALID; i++)
+		sd->retries[i] = -1;
+
+	sd->removed = TRUE;
+	sd->initialized = FALSE;
+}
+
+static void sim_send_set_uicc_subscription(struct sim_data *sd, int slot_id,
+				int app_index, int sub_id, int sub_status)
+{
+	struct parcel rilp;
+
+	DBG("");
+
+	g_ril_request_set_uicc_subscription(sd->ril, slot_id, app_index,
+						sub_id, sub_status, &rilp);
+
+	g_ril_send(sd->ril, RIL_REQUEST_SET_UICC_SUBSCRIPTION, rilp.data,
+		rilp.size, NULL, NULL, NULL);
+}
+
+static int sim_select_uicc_subscription(struct sim_data *sim,
+			struct sim_status *status, struct sim_app **apps)
+{
+	int slot_id = 0;
+	int selected_app = -1;
+	unsigned int i;
+
+	for (i = 0; i < status->num_apps; i++) {
+		switch (apps[i]->app_type) {
+		case RIL_APPTYPE_UNKNOWN:
+			continue;
+		case RIL_APPTYPE_USIM:
+		case RIL_APPTYPE_RUIM:
+			if (selected_app != -1) {
+				switch (apps[selected_app]->app_type) {
+				case RIL_APPTYPE_USIM:
+				case RIL_APPTYPE_RUIM:
+					break;
+				default:
+					selected_app = i;
+				}
+			} else {
+				selected_app = i;
+			}
+			break;
+		default:
+			if (selected_app == -1)
+				selected_app = i;
+		}
+	}
+
+	DBG("Select app %d for subscription.", selected_app);
+
+	if (selected_app != -1)
+		/* Number 1 means activates that app */
+		sim_send_set_uicc_subscription(sim, slot_id, selected_app,
+						slot_id, 1);
+
+	return selected_app;
+}
+
 static void sim_status_cb(struct ril_msg *message, gpointer user_data)
 {
 	struct ofono_sim *sim = user_data;
 	struct sim_data *sd = ofono_sim_get_data(sim);
 	struct sim_app *apps[MAX_UICC_APPS];
 	struct sim_status status;
-	guint i = 0;
-	guint search_index = -1;
 	struct parcel rilp;
 
 	DBG("");
 
-	if (ril_util_parse_sim_status(sd->ril, message,	&status, apps) &&
+	if (ril_util_parse_sim_status(sd->ril, message, &status, apps) &&
 		status.num_apps) {
 
-		DBG("num_apps: %d gsm_umts_index: %d", status.num_apps,
-			status.gsm_umts_index);
-
 		/* TODO(CDMA): need some kind of logic to
 		 * set the correct app_index,
 		 */
-		search_index = status.gsm_umts_index;
+		int app_index = status.gsm_umts_index;
 
-		for (i = 0; i < status.num_apps; i++) {
-			if (i == search_index &&
-				apps[i]->app_type != RIL_APPTYPE_UNKNOWN) {
-				current_active_app = apps[i]->app_type;
-				configure_active_app(sd, apps[i], i);
-				set_pin_lock_state(sim, apps[i]);
-				break;
-			}
+		if (app_index < 0) {
+			app_index = sim_select_uicc_subscription(sd,
+								&status, apps);
+		}
+		if (app_index >= 0 && app_index < (int)status.num_apps &&
+			apps[app_index]->app_type != RIL_APPTYPE_UNKNOWN) {
+			current_active_app = apps[app_index]->app_type;
+			configure_active_app(sd, apps[app_index], app_index);
 		}
 
-		if (sd->sim_registered == FALSE) {
-			ofono_sim_register(sim);
-			sd->sim_registered = TRUE;
-		} else
+		sd->removed = FALSE;
+
+		if (sd->passwd_state != OFONO_SIM_PASSWORD_INVALID) {
+			/*
+			 * ril_util_parse_sim_status returns true only when
+			 * card status is RIL_CARDSTATE_PRESENT,
+			 * ofono_sim_inserted_notify returns if status doesn't
+			 * change. So can notify core always in this branch.
+			 */
+			ofono_sim_inserted_notify(sim, TRUE);
+
 			/* TODO: There doesn't seem to be any other
 			 * way to force the core SIM code to
 			 * recheck the PIN.
@@ -650,46 +704,16 @@ static void sim_status_cb(struct ril_msg *message, gpointer user_data)
 			 * more appropriate call here??
 			 * __ofono_sim_refresh(sim, NULL, TRUE, TRUE);
 			 */
-			DBG("sd->card_state:%u",sd->card_state);
-			if (sd->card_state != RIL_CARDSTATE_PRESENT) {
-				ofono_sim_inserted_notify(sim, TRUE);
-				sd->card_state = RIL_CARDSTATE_PRESENT;
-			}
-
-		if (current_passwd) {
-			if (!strcmp(current_passwd, defaultpasswd)) {
-			__ofono_sim_recheck_pin(sim);
-			} else if (sd->passwd_state !=
-						OFONO_SIM_PASSWORD_SIM_PIN) {
-				__ofono_sim_recheck_pin(sim);
-			} else if (sd->passwd_state ==
-						OFONO_SIM_PASSWORD_SIM_PIN) {
-				parcel_init(&rilp);
-
-				parcel_w_int32(&rilp,
-					ENTER_SIM_PIN_PARAMS);
-				parcel_w_string(&rilp, current_passwd);
-				parcel_w_string(&rilp, sd->aid_str);
-
-				g_ril_send(sd->ril,
-						RIL_REQUEST_ENTER_SIM_PIN,
-						rilp.data, rilp.size, NULL,
-						NULL, g_free);
-
-				parcel_free(&rilp);
-			}
-		} else {
 			__ofono_sim_recheck_pin(sim);
 		}
 
 		if (current_online_state == RIL_ONLINE_PREF) {
 
-			parcel_init(&rilp);
-
 			parcel_init(&rilp);
 			parcel_w_int32(&rilp, 1);
 			parcel_w_int32(&rilp, 1);
 
+			ofono_info("RIL_REQUEST_RADIO_POWER ON");
 			g_ril_send(sd->ril,
 					RIL_REQUEST_RADIO_POWER,
 					rilp.data,
@@ -707,17 +731,13 @@ static void sim_status_cb(struct ril_msg *message, gpointer user_data)
 			current_online_state = RIL_ONLINE_PREF;
 
 		if (status.card_state == RIL_CARDSTATE_ABSENT) {
-			DBG("sd->card_state:%u,status.card_state:%u,",
-				sd->card_state, status.card_state);
-			ofono_sim_inserted_notify(sim, FALSE);
-			sd->card_state = RIL_CARDSTATE_ABSENT;
+			ofono_info("%s: RIL_CARDSTATE_ABSENT", __func__);
 
-			if (current_passwd)
-				g_stpcpy(current_passwd, defaultpasswd);
+			free_sim_state(sd);
+
+			ofono_sim_inserted_notify(sim, FALSE);
 		}
 	}
-
-	/* TODO: if no SIM present, handle emergency calling. */
 }
 
 static int send_get_sim_status(struct ofono_sim *sim)
@@ -754,16 +774,73 @@ static void ril_query_pin_retries(struct ofono_sim *sim,
 	CALLBACK_WITH_SUCCESS(cb, sd->retries, data);
 }
 
+static void ril_query_passwd_state_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	struct ofono_sim *sim = cbd->user;
+	struct sim_data *sd = ofono_sim_get_data(sim);
+	ofono_sim_passwd_cb_t cb = cbd->cb;
+	void *data = cbd->data;
+	struct sim_app *apps[MAX_UICC_APPS];
+	struct sim_status status;
+	gint state = ofono_sim_get_state(sim);
+
+	if (ril_util_parse_sim_status(sd->ril, message, &status, apps) &&
+		status.num_apps) {
+
+		/* TODO(CDMA): need some kind of logic to
+		 * set the correct app_index,
+		 */
+		int app_index = status.gsm_umts_index;
+
+		if (app_index >= 0 && app_index < (int)status.num_apps &&
+			apps[app_index]->app_type != RIL_APPTYPE_UNKNOWN) {
+			current_active_app = apps[app_index]->app_type;
+			configure_active_app(sd, apps[app_index], app_index);
+		}
+
+		ril_util_free_sim_apps(apps, status.num_apps);
+	}
+	DBG("passwd_state %u", sd->passwd_state);
+
+	/* if pin code required cannot be initialized yet*/
+	if (sd->passwd_state == OFONO_SIM_PASSWORD_SIM_PIN)
+		sd->initialized = FALSE;
+	/*
+	 * To prevent double call to sim_initialize_after_pin from
+	 * sim_pin_query_cb we must prevent calling sim_pin_query_cb
+	 * when !OFONO_SIM_STATE_READY && OFONO_SIM_PASSWORD_NONE
+	*/
+	if ((state == OFONO_SIM_STATE_READY) || (sd->initialized == FALSE) ||
+				(sd->passwd_state != OFONO_SIM_PASSWORD_NONE)){
+
+		if (sd->passwd_state == OFONO_SIM_PASSWORD_NONE)
+			sd->initialized = TRUE;
+
+		if (state == OFONO_SIM_STATE_LOCKED_OUT)
+			sd->initialized = FALSE;
+
+		if (sd->passwd_state == OFONO_SIM_PASSWORD_INVALID)
+			CALLBACK_WITH_FAILURE(cb, -1, data);
+		else
+			CALLBACK_WITH_SUCCESS(cb, sd->passwd_state, data);
+	}
+
+}
+
 static void ril_query_passwd_state(struct ofono_sim *sim,
 					ofono_sim_passwd_cb_t cb, void *data)
 {
 	struct sim_data *sd = ofono_sim_get_data(sim);
-	DBG("passwd_state %u", sd->passwd_state);
+	struct cb_data *cbd = cb_data_new2(sim, cb, data);
+	int request = RIL_REQUEST_GET_SIM_STATUS;
+	guint ret;
+
+	ret = g_ril_send(sd->ril, request,
+			NULL, 0, ril_query_passwd_state_cb, cbd, g_free);
+
+	g_ril_print_request_no_args(sd->ril, ret, request);
 
-	if (sd->passwd_state == OFONO_SIM_PASSWORD_INVALID)
-		CALLBACK_WITH_FAILURE(cb, -1, data);
-	else
-		CALLBACK_WITH_SUCCESS(cb, sd->passwd_state, data);
 }
 
 static void ril_pin_change_state_cb(struct ril_msg *message, gpointer user_data)
@@ -773,8 +850,9 @@ static void ril_pin_change_state_cb(struct ril_msg *message, gpointer user_data)
 	struct sim_data *sd = cbd->user;
 	struct parcel rilp;
 	int retry_count;
-	int retries[OFONO_SIM_PASSWORD_INVALID];
 	int passwd_type;
+	int i;
+
 	/* There is no reason to ask SIM status until
 	 * unsolicited sim status change indication
 	 * Looks like state does not change before that.
@@ -784,18 +862,19 @@ static void ril_pin_change_state_cb(struct ril_msg *message, gpointer user_data)
 	ril_util_init_parcel(message, &rilp);
 	parcel_r_int32(&rilp);
 	retry_count = parcel_r_int32(&rilp);
-	retries[passwd_type] = retry_count;
-	sd->retries[passwd_type] = retries[passwd_type];
 
-	/* TODO: re-bfactor to not use macro for FAILURE; doesn't return error! */
+	for (i = 0; i < OFONO_SIM_PASSWORD_INVALID; i++)
+		sd->retries[i] = -1;
 
+	sd->retries[passwd_type] = retry_count;
+
+	DBG("result=%d passwd_type=%d retry_count=%d",
+		message->error, passwd_type, retry_count);
 	if (message->error == RIL_E_SUCCESS) {
 		CALLBACK_WITH_SUCCESS(cb, cbd->data);
 		g_ril_print_response_no_args(sd->ril, message);
 
 	} else {
-		if (current_passwd)
-			g_stpcpy(current_passwd, defaultpasswd);
 		CALLBACK_WITH_FAILURE(cb, cbd->data);
 	}
 
@@ -813,9 +892,6 @@ static void ril_pin_send(struct ofono_sim *sim, const char *passwd,
 	sd->passwd_type = OFONO_SIM_PASSWORD_SIM_PIN;
 	cbd->user = sd;
 
-	if (current_passwd)
-		g_stpcpy(current_passwd, passwd);
-
 	parcel_init(&rilp);
 
 	parcel_w_int32(&rilp, ENTER_SIM_PIN_PARAMS);
@@ -837,11 +913,53 @@ static void ril_pin_send(struct ofono_sim *sim, const char *passwd,
 	}
 }
 
-static void ril_pin_change_state(struct ofono_sim *sim,
-					enum ofono_sim_password_type passwd_type,
-					int enable, const char *passwd,
-					ofono_sim_lock_unlock_cb_t cb, void *data)
+static int ril_perso_change_state(struct ofono_sim *sim,
+				enum ofono_sim_password_type passwd_type,
+				int enable, const char *passwd,
+				ofono_sim_lock_unlock_cb_t cb, void *data)
 {
+	struct sim_data *sd = ofono_sim_get_data(sim);
+	struct cb_data *cbd = cb_data_new(cb, data);
+	struct parcel rilp;
+	int request = 0;
+	int ret = 0;
+	sd->passwd_type = passwd_type;
+	cbd->user = sd;
+
+	parcel_init(&rilp);
+
+	switch (passwd_type) {
+	case OFONO_SIM_PASSWORD_PHNET_PIN:
+		if (enable) {
+			DBG("Not supported, enable=%d", enable);
+			goto end;
+		}
+		request = RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION;
+		parcel_w_int32(&rilp, RIL_PERSOSUBSTATE_SIM_NETWORK);
+		parcel_w_string(&rilp, (char *) passwd);
+		break;
+	default:
+		DBG("Not supported, type=%d", passwd_type);
+		goto end;
+	}
+
+	ret = g_ril_send(sd->ril, request,
+				rilp.data, rilp.size, ril_pin_change_state_cb,
+				cbd, g_free);
+
+	g_ril_print_request(sd->ril, ret, request);
+
+end:
+	parcel_free(&rilp);
+	return ret;
+}
+
+static void ril_pin_change_state(struct ofono_sim *sim,
+				enum ofono_sim_password_type passwd_type,
+				int enable, const char *passwd,
+				ofono_sim_lock_unlock_cb_t cb, void *data)
+{
+	DBG("passwd_type=%d", passwd_type);
 	struct sim_data *sd = ofono_sim_get_data(sim);
 	struct cb_data *cbd = cb_data_new(cb, data);
 	struct parcel rilp;
@@ -861,8 +979,6 @@ static void ril_pin_change_state(struct ofono_sim *sim,
 	 */
 	switch (passwd_type) {
 	case OFONO_SIM_PASSWORD_SIM_PIN:
-		if (current_passwd)
-			g_stpcpy(current_passwd, passwd);
 		g_ril_append_print_buf(sd->ril, "(SC,");
 		parcel_w_string(&rilp, "SC");
 		break;
@@ -879,9 +995,9 @@ static void ril_pin_change_state(struct ofono_sim *sim,
 		parcel_w_string(&rilp, "P2");
 		break;
 	case OFONO_SIM_PASSWORD_PHNET_PIN:
-		g_ril_append_print_buf(sd->ril, "(PN,");
-		parcel_w_string(&rilp, "PN");
-		break;
+		ret = ril_perso_change_state(sim, passwd_type, enable, passwd,
+						cb, data);
+		goto end;
 	case OFONO_SIM_PASSWORD_PHNETSUB_PIN:
 		g_ril_append_print_buf(sd->ril, "(PU,");
 		parcel_w_string(&rilp, "PU");
@@ -895,8 +1011,7 @@ static void ril_pin_change_state(struct ofono_sim *sim,
 		parcel_w_string(&rilp, "PC");
 		break;
 	default:
-		CALLBACK_WITH_FAILURE(cb, data);
-		return;
+		goto end;
 	}
 
 	if (enable)
@@ -923,6 +1038,7 @@ static void ril_pin_change_state(struct ofono_sim *sim,
 
 	g_ril_print_request(sd->ril, ret, request);
 
+end:
 	parcel_free(&rilp);
 
 	if (ret <= 0) {
@@ -944,9 +1060,6 @@ static void ril_pin_send_puk(struct ofono_sim *sim,
 	sd->passwd_type = OFONO_SIM_PASSWORD_SIM_PUK;
 	cbd->user = sd;
 
-	if (current_passwd)
-		g_stpcpy(current_passwd, passwd);
-
 	parcel_init(&rilp);
 
 	parcel_w_int32(&rilp, ENTER_SIM_PUK_PARAMS);
@@ -995,8 +1108,6 @@ static void ril_change_passwd(struct ofono_sim *sim,
 
 	if (passwd_type == OFONO_SIM_PASSWORD_SIM_PIN2)
 		request = RIL_REQUEST_CHANGE_SIM_PIN2;
-	else if (current_passwd)
-		g_stpcpy(current_passwd, new_passwd);
 
 	ret = g_ril_send(sd->ril, request, rilp.data, rilp.size,
 			ril_pin_change_state_cb, cbd, g_free);
@@ -1022,15 +1133,14 @@ static gboolean ril_sim_register(gpointer user)
 
 	DBG("");
 
-	sd->idle_id = 0;
+	ofono_sim_register(sim);
 
 	send_get_sim_status(sim);
 
-	g_ril_register(sd->ril, RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED,
+	sd->idle_id = 0;
+	g_ril_register(sd->ril,
+			RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED,
 			(GRilNotifyFunc) ril_sim_status_changed, sim);
-
-	/* TODO: should we also register for RIL_UNSOL_SIM_REFRESH? */
-
 	return FALSE;
 }
 
@@ -1045,13 +1155,6 @@ static int ril_sim_probe(struct ofono_sim *sim, unsigned int vendor,
 
 	sd = g_new0(struct sim_data, 1);
 	sd->ril = g_ril_clone(ril);
-	sd->aid_str = NULL;
-	sd->app_str = NULL;
-	sd->app_type = RIL_APPTYPE_UNKNOWN;
-	sd->passwd_state = OFONO_SIM_PASSWORD_NONE;
-	sd->passwd_type = OFONO_SIM_PASSWORD_NONE;
-	sd->sim_registered = FALSE;
-	sd->card_state = RIL_CARDSTATE_ABSENT;
 
 	for (i = 0; i < OFONO_SIM_PASSWORD_INVALID; i++)
 		sd->retries[i] = -1;
@@ -1078,13 +1181,18 @@ static int ril_sim_probe(struct ofono_sim *sim, unsigned int vendor,
 
 static void ril_sim_remove(struct ofono_sim *sim)
 {
+	DBG("");
 	struct sim_data *sd = ofono_sim_get_data(sim);
 
 	ofono_sim_set_data(sim, NULL);
 
-	if (sd->idle_id > 0)
+	if (sd->idle_id > 0) {
 		g_source_remove(sd->idle_id);
+		sd->idle_id = 0;
+	}
 
+	g_free(sd->aid_str);
+	g_free(sd->app_str);
 	g_ril_unref(sd->ril);
 	g_free(sd);
 }
@@ -1105,17 +1213,6 @@ static struct ofono_sim_driver driver = {
 	.change_passwd		= ril_change_passwd,
 	.query_pin_retries	= ril_query_pin_retries,
 /*
- * TODO: Implmenting PIN/PUK support requires defining
- * the following driver methods.
- *
- * In the meanwhile, as long as the SIM card is present,
- * and unlocked, the core SIM code will check for the
- * presence of query_passwd_state, and if null, then the
- * function sim_initialize_after_pin() is called.
- *
- *	.query_pin_retries	= ril_pin_retries_query,
- *	.query_locked		= ril_pin_query_enabled,
- *
  * TODO: Implementing SIM write file IO support requires
  * the following functions to be defined.
  *

ofono/drivers/rilmodem/sms.c

@@ -38,10 +38,18 @@
 #include <ofono/log.h>
 #include <ofono/modem.h>
 #include <ofono/sms.h>
+#include <ofono/types.h>
+#include <ofono/sim.h>
+
 #include "smsutil.h"
 #include "util.h"
-
 #include "rilmodem.h"
+#include "simutil.h"
+
+#define SIM_EFSMS_FILEID	0x6F3C
+#define EFSMS_LENGTH		176
+
+unsigned char path[4] = {0x3F, 0x00, 0x7F, 0x10};
 
 struct sms_data {
 	GRil *ril;
@@ -131,7 +139,7 @@ static void ril_csca_query_cb(struct ril_msg *message, gpointer user_data)
 		sca.number[OFONO_MAX_PHONE_NUMBER_LENGTH] = '\0';
 
 		DBG("csca_query_cb: %s, %d", sca.number, sca.type);
-
+		g_free(temp_buf); /*g_utf16_to_utf8 used by parcel_r_string*/
 		cb(&error, &sca, cbd->data);
 	} else {
 		ofono_error("return value invalid");
@@ -168,10 +176,14 @@ static void submit_sms_cb(struct ril_msg *message, gpointer user_data)
 	int mr;
 
 	if (message->error == RIL_E_SUCCESS) {
-		ofono_info("sms sending succesful");
+		ofono_info("sms sending successful");
 		decode_ril_error(&error, "OK");
+	} else if (message->error == RIL_E_GENERIC_FAILURE) {
+		ofono_info("not allowed by MO SMS control, do not retry");
+		error.type = OFONO_ERROR_TYPE_CMS;
+		error.error = 500;
 	} else {
-		ofono_error("sms sending failed");
+		ofono_error("sms sending failed, retry");
 		decode_ril_error(&error, "FAIL");
 	}
 
@@ -230,6 +242,8 @@ static void ril_cmgs(struct ofono_sms *sms, const unsigned char *pdu,
 				submit_sms_cb, cbd, g_free);
 
 	g_ril_append_print_buf(sd->ril, "(%s)", tpdu);
+	g_free(tpdu);
+	tpdu = NULL;
 	g_ril_print_request(sd->ril, ret, request);
 
 	parcel_free(&rilp);
@@ -248,19 +262,21 @@ static void ril_ack_delivery_cb(struct ril_msg *message, gpointer user_data)
 			"SMS acknowledgement failed: Further SMS reception is not guaranteed");
 }
 
-static void ril_ack_delivery(struct ofono_sms *sms)
+static void ril_ack_delivery(struct ofono_sms *sms, int error)
 {
 	struct sms_data *sd = ofono_sms_get_data(sms);
 	struct parcel rilp;
 	int ret;
 	int request = RIL_REQUEST_SMS_ACKNOWLEDGE;
+	int code = 0;
+
+	if (!error)
+		code = 0xFF;
 
 	parcel_init(&rilp);
 	parcel_w_int32(&rilp, 2); /* Number of int32 values in array */
-	parcel_w_int32(&rilp, 1); /* Successful receipt */
-	parcel_w_int32(&rilp, 0); /* error code */
-
-	/* TODO: should ACK be sent for either of the error cases? */
+	parcel_w_int32(&rilp, error); /* Successful (1)/Failed (0) receipt */
+	parcel_w_int32(&rilp, code); /* error code */
 
 	/* ACK the incoming NEW_SMS */
 	ret = g_ril_send(sd->ril, request,
@@ -285,6 +301,9 @@ static void ril_sms_notify(struct ril_msg *message, gpointer user_data)
 	long ril_buf_len;
 	guchar *ril_data;
 
+	ril_pdu = NULL;
+	ril_data = NULL;
+
 	DBG("req: %d; data_len: %d", message->req, message->buf_len);
 
 	switch (message->req) {
@@ -317,6 +336,8 @@ static void ril_sms_notify(struct ril_msg *message, gpointer user_data)
 	ofono_info("sms received, smsc_len is %d", smsc_len);
 
 	g_ril_append_print_buf(sd->ril, "(%s)", ril_pdu);
+	g_free(ril_pdu);
+	ril_pdu = NULL;
 	g_ril_print_unsol(sd->ril, message);
 
 	if (message->req == RIL_UNSOL_RESPONSE_NEW_SMS) {
@@ -329,14 +350,116 @@ static void ril_sms_notify(struct ril_msg *message, gpointer user_data)
 						ril_buf_len - smsc_len);
 	}
 
-	ril_ack_delivery(sms);
+	g_free(ril_data);
+	ril_data = NULL;
+
+	ril_ack_delivery(sms, TRUE);
 
 	return;
 
 error:
+	g_free(ril_pdu);
+	ril_pdu = NULL;
+
+	g_free(ril_data);
+	ril_data = NULL;
+
+	ril_ack_delivery(sms, FALSE);
+
 	ofono_error("Unable to parse NEW_SMS notification");
 }
 
+static void ril_new_sms_on_sim_cb(struct ril_msg *message, gpointer user_data)
+{
+	DBG("");
+	if (message->error == RIL_E_SUCCESS)
+		ofono_info("sms deleted from sim");
+	else
+		ofono_error("deleting sms from sim failed");
+}
+
+static void ril_request_delete_sms_om_sim(struct ofono_sms *sms,int record)
+{
+	struct sms_data *data = ofono_sms_get_data(sms);
+	struct parcel rilp;
+	int request = RIL_REQUEST_DELETE_SMS_ON_SIM;
+	int ret;
+
+	DBG("Deleting record: %d", record);
+
+	parcel_init(&rilp);
+	parcel_w_int32(&rilp, 1); /* Number of int32 values in array */
+	parcel_w_int32(&rilp, record);
+
+	ret = g_ril_send(data->ril, request, rilp.data,
+				rilp.size, ril_new_sms_on_sim_cb, NULL, NULL);
+
+	parcel_free(&rilp);
+
+	if (ret <= 0)
+		ofono_error("cannot delete sms from sim");
+}
+
+static void ril_read_sms_on_sim_cb(const struct ofono_error *error,
+					const unsigned char *sdata,
+					int length, void *data)
+{
+	struct cb_data *cbd = data;
+	struct ofono_sms *sms = cbd->user;
+	int record;
+	unsigned int smsc_len;
+
+	if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
+		ofono_error("cannot read sms from sim");
+		goto exit;
+	}
+
+	/*
+	 * It seems when reading EFsms RIL returns the whole record including
+	 * the first status byte therefore we ignore that as we are only
+	 * interested of the following pdu
+	 */
+	/* The first octect in the pdu contains the SMSC address length
+	 * which is the X following octects it reads. We add 1 octet to
+	 * the read length to take into account this read octet in order
+	 * to calculate the proper tpdu length.
+	 */
+	smsc_len = sdata[1] + 1;
+
+	ofono_sms_deliver_notify(sms, sdata + 1, length - 1,
+				 length - smsc_len - 1);
+
+	record = (int)cbd->data;
+	ril_request_delete_sms_om_sim(sms,record);
+
+exit:
+	g_free(cbd);
+}
+
+static void ril_new_sms_on_sim(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_sms *sms = user_data;
+	struct parcel rilp;
+	int record;
+
+	ofono_info("new sms on sim");
+
+	ril_util_init_parcel(message, &rilp);
+
+	/* data length of the response */
+	record = parcel_r_int32(&rilp);
+
+	if (record > 0) {
+		record = parcel_r_int32(&rilp);
+		struct cb_data *cbd = cb_data_new2(sms, NULL, (void*)record);
+		DBG(":%d", record);
+		get_sim_driver()->read_file_linear(get_sim(), SIM_EFSMS_FILEID,
+						record, EFSMS_LENGTH, path,
+						sizeof(path),
+						ril_read_sms_on_sim_cb, cbd);
+	}
+}
+
 static gboolean ril_delayed_register(gpointer user_data)
 {
 	struct ofono_sms *sms = user_data;
@@ -352,6 +475,8 @@ static gboolean ril_delayed_register(gpointer user_data)
 			ril_sms_notify, sms);
 	g_ril_register(data->ril, RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT,
 			ril_sms_notify, sms);
+	g_ril_register(data->ril, RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM,
+			ril_new_sms_on_sim, sms);
 
 	/* This makes the timeout a single-shot */
 	return FALSE;

ofono/drivers/rilmodem/stk.c

@@ -0,0 +1,342 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2014 Jolla 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 <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include <glib.h>
+
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/stk.h>
+
+#include "gril.h"
+#include "util.h"
+
+#include "rilmodem.h"
+#include "ril_constants.h"
+
+struct stk_data {
+	GRil *ril;
+};
+
+gboolean subscribed;
+
+static void ril_envelope_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_stk_envelope_cb_t cb = cbd->cb;
+	struct ofono_error error;
+
+	DBG("");
+
+	if (message->error == RIL_E_SUCCESS) {
+		decode_ril_error(&error, "OK");
+	} else {
+		DBG("Envelope reply failure: %s",
+				ril_error_to_string(message->error));
+		decode_ril_error(&error, "FAIL");
+	}
+
+	cb(&error, NULL, 0, cbd->data);
+}
+
+static void ril_stk_envelope(struct ofono_stk *stk, int length,
+				const unsigned char *command,
+				ofono_stk_envelope_cb_t cb, void *data)
+{
+	struct stk_data *sd = ofono_stk_get_data(stk);
+	struct cb_data *cbd = cb_data_new(cb, data);
+	struct parcel rilp;
+	char *hex_envelope = NULL;
+	int request = RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND;
+	guint ret;
+
+	DBG("");
+
+	hex_envelope = encode_hex(command, length, 0);
+	DBG("rilmodem envelope: %s", hex_envelope);
+
+	parcel_init(&rilp);
+	parcel_w_string(&rilp, hex_envelope);
+	g_free(hex_envelope);
+	hex_envelope = NULL;
+
+	ret = g_ril_send(sd->ril, request,
+				rilp.data, rilp.size, ril_envelope_cb,
+				cbd, g_free);
+
+	parcel_free(&rilp);
+
+	if (ret <= 0) {
+			g_free(cbd);
+			CALLBACK_WITH_FAILURE(cb, NULL, -1, data);
+		}
+}
+
+static void ril_tr_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_stk_generic_cb_t cb = cbd->cb;
+	struct ofono_error error;
+
+	DBG("");
+
+	if (message->error == RIL_E_SUCCESS) {
+		decode_ril_error(&error, "OK");
+	} else {
+		DBG("Error in sending terminal response");
+		ofono_error("Error in sending terminal response");
+		decode_ril_error(&error, "FAIL");
+	}
+
+	cb(&error, cbd->data);
+}
+
+static void ril_stk_terminal_response(struct ofono_stk *stk, int length,
+					const unsigned char *resp,
+					ofono_stk_generic_cb_t cb, void *data)
+{
+	struct stk_data *sd = ofono_stk_get_data(stk);
+	struct cb_data *cbd = cb_data_new(cb, data);
+	struct parcel rilp;
+	char *hex_tr = NULL;
+	int request = RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE;
+	guint ret;
+
+	DBG("");
+
+	hex_tr = encode_hex(resp, length, 0);
+	DBG("rilmodem terminal response: %s", hex_tr);
+
+	parcel_init(&rilp);
+	parcel_w_string(&rilp, hex_tr);
+	g_free(hex_tr);
+	hex_tr = NULL;
+
+	ret = g_ril_send(sd->ril, request,
+				rilp.data, rilp.size, ril_tr_cb,
+				cbd, g_free);
+
+	parcel_free(&rilp);
+
+	if (ret <= 0) {
+			g_free(cbd);
+			CALLBACK_WITH_FAILURE(cb, data);
+		}
+}
+
+static void ril_stk_user_confirmation(struct ofono_stk *stk,
+					ofono_bool_t confirm)
+{
+	struct stk_data *sd = ofono_stk_get_data(stk);
+	struct parcel rilp;
+	int request = RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM;
+	int ret;
+
+	DBG("");
+
+	/* Only pcmd needing user confirmation is call set up
+	 * RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM
+	 */
+	parcel_init(&rilp);
+	parcel_w_int32(&rilp, 1);		/* size of array */
+	parcel_w_int32(&rilp, confirm);	/* yes/no */
+
+	/* fire and forget i.e. not waiting for the callback*/
+	ret = g_ril_send(sd->ril, request, rilp.data,
+		 rilp.size, NULL, NULL, NULL);
+
+	g_ril_print_request_no_args(sd->ril, ret, request);
+
+	parcel_free(&rilp);
+}
+
+static void ril_stk_pcmd_notify(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_stk *stk = user_data;
+	struct parcel rilp;
+	char *pcmd = NULL;
+	guchar *pdu = NULL;
+	long len;
+
+	DBG("");
+
+	ril_util_init_parcel(message, &rilp);
+	pcmd = parcel_r_string(&rilp);
+	DBG("pcmd: %s", pcmd);
+
+	pdu = decode_hex((const char *) pcmd,
+			strlen(pcmd),
+			&len, -1);
+
+	g_free(pcmd);
+	ofono_stk_proactive_command_notify(stk, len, (const guchar *)pdu);
+	g_free(pdu);
+}
+
+static void ril_stk_event_notify(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_stk *stk = user_data;
+	struct parcel rilp;
+	char *pcmd = NULL;
+	guchar *pdu = NULL;
+	long len;
+
+	DBG("");
+
+	/* Proactive command has been handled by the modem. */
+	ril_util_init_parcel(message, &rilp);
+	pcmd = parcel_r_string(&rilp);
+	DBG("pcmd: %s", pcmd);
+	pdu = decode_hex((const char *) pcmd,
+			strlen(pcmd),
+			&len, -1);
+	g_free(pcmd);
+	pcmd = NULL;
+	ofono_stk_proactive_command_handled_notify(stk, len,
+			(const guchar *)pdu);
+	g_free(pdu);
+}
+
+static void ril_stk_session_end_notify(struct ril_msg *message,
+					gpointer user_data)
+{
+	struct ofono_stk *stk = user_data;
+
+	DBG("");
+
+	ofono_stk_proactive_session_end_notify(stk);
+}
+
+static void ril_stk_agent_ready(struct ofono_stk *stk)
+{
+	struct stk_data *sd = ofono_stk_get_data(stk);
+	int request = RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING;
+	int ret;
+
+	DBG("");
+
+	if (!subscribed) {
+		DBG("Subscribing notifications");
+		g_ril_register(sd->ril, RIL_UNSOL_STK_PROACTIVE_COMMAND,
+				ril_stk_pcmd_notify, stk);
+
+		g_ril_register(sd->ril, RIL_UNSOL_STK_SESSION_END,
+				ril_stk_session_end_notify, stk);
+
+		g_ril_register(sd->ril, RIL_UNSOL_STK_EVENT_NOTIFY,
+				ril_stk_event_notify, stk);
+		subscribed = TRUE;
+	}
+
+	/* fire and forget i.e. not waiting for the callback*/
+	ret = g_ril_send(sd->ril, request, NULL, 0,
+		 NULL, NULL, NULL);
+
+	g_ril_print_request_no_args(sd->ril, ret, request);
+}
+
+void ril_stk_set_lang()
+{
+	gchar *contents;
+	GError *err = NULL;
+
+	if (!g_file_get_contents(UI_LANG, &contents, NULL, &err)) {
+		if (err)
+			ofono_error("cannot open %s error: %d: message: %s",
+					UI_LANG, err->code, err->message);
+		g_error_free(err);
+	} else {
+		gchar *pch = g_strrstr(contents, CFG_LANG);
+		/* Set System UI lang to env LANG */
+		if (pch) {
+			setenv("LANG", pch + strlen(CFG_LANG), 1);
+			DBG("LANG %s", getenv("LANG"));
+		}
+		g_free(contents);
+	}
+}
+
+static int ril_stk_probe(struct ofono_stk *stk, unsigned int vendor, void *data)
+{
+	GRil *ril = data;
+	struct stk_data *sd;
+
+	DBG("");
+
+	sd = g_try_new0(struct stk_data, 1);
+	if (sd == NULL)
+		return -ENOMEM;
+
+	sd->ril = g_ril_clone(ril);
+	ofono_stk_set_data(stk, sd);
+
+	/* Register interface in this phase for stk agent */
+	ofono_stk_register(stk);
+
+	subscribed = FALSE;
+
+	/* UI language for local info */
+	ril_stk_set_lang();
+
+	return 0;
+}
+
+static void ril_stk_remove(struct ofono_stk *stk)
+{
+	struct stk_data *sd = ofono_stk_get_data(stk);
+
+	DBG("");
+
+	ofono_stk_set_data(stk, NULL);
+
+	g_ril_unref(sd->ril);
+	g_free(sd);
+}
+
+static struct ofono_stk_driver driver = {
+	.name			= "rilmodem",
+	.probe			= ril_stk_probe,
+	.remove			= ril_stk_remove,
+	.envelope		= ril_stk_envelope,
+	.terminal_response	= ril_stk_terminal_response,
+	.user_confirmation	= ril_stk_user_confirmation,
+	.ready			= ril_stk_agent_ready
+};
+
+void ril_stk_init(void)
+{
+	ofono_stk_driver_register(&driver);
+}
+
+void ril_stk_exit(void)
+{
+	ofono_stk_driver_unregister(&driver);
+}

ofono/drivers/rilmodem/ussd.c

@@ -68,19 +68,37 @@ static void ril_ussd_request(struct ofono_ussd *ussd, int dcs,
 	enum sms_charset charset;
 	int ret = -1;
 
-	ofono_info("send ussd");
+	ofono_info("send ussd, len:%d", len);
 
 	if (cbs_dcs_decode(dcs, NULL, NULL, &charset,
 					NULL, NULL, NULL)) {
 		if (charset == SMS_CHARSET_7BIT) {
 			unsigned char unpacked_buf[182] = "";
 			long written;
+			int length;
 
 			unpack_7bit_own_buf(pdu, len, 0, TRUE,
 					sizeof(unpacked_buf), &written, 0,
 					unpacked_buf);
 
 			if (written >= 1) {
+				/*
+				 * When USSD was packed, additional CR
+				   might have been added (according to
+				   23.038 6.1.2.3.1). So if the last
+				   character is CR, it should be removed
+				   here. And in addition written doesn't
+				   contain correct length...
+
+				   Over 2 characters long USSD string must
+				   end with # (checked in
+				   valid_ussd_string() ), so it should be
+				   safe to remove extra CR.
+				*/
+				length = strlen((char *)unpacked_buf);
+				if (length > 2 &&
+				    unpacked_buf[length-1] == '\r')
+					unpacked_buf[length-1] = 0;
 				struct parcel rilp;
 				parcel_init(&rilp);
 				parcel_w_string(&rilp, (char *)unpacked_buf);
@@ -149,9 +167,9 @@ static void ril_ussd_notify(struct ril_msg *message, gpointer user_data)
 {
 	struct ofono_ussd *ussd = user_data;
 	struct parcel rilp;
-	gchar *ussd_from_network;
-	gchar *type;
-	gint ussdtype;
+	gchar *ussd_from_network = NULL;
+	gchar *type = NULL;
+	gint ussdtype = 0;
 
 	ofono_info("ussd_received");
 
@@ -159,13 +177,17 @@ static void ril_ussd_notify(struct ril_msg *message, gpointer user_data)
 	parcel_r_int32(&rilp);
 	type = parcel_r_string(&rilp);
 	ussdtype = g_ascii_xdigit_value(*type);
+	g_free(type);
+	type = NULL;
 	ussd_from_network = parcel_r_string(&rilp);
 
-	if (ussd_from_network)
+	/* ussd_from_network not freed because core does that if dcs is 0xFF */
+	if (ussd_from_network) {
+		DBG("ussd_received, length %d", strlen(ussd_from_network));
 		ofono_ussd_notify(ussd, ussdtype, 0xFF,
 			(const unsigned char *)ussd_from_network,
 			strlen(ussd_from_network));
-	else
+	} else
 		ofono_ussd_notify(ussd, ussdtype, 0, NULL, 0);
 
 	return;

ofono/drivers/rilmodem/voicecall.c

@@ -4,7 +4,7 @@
  *
  *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
  *  Copyright (C) 2012 Canonical Ltd.
- *  Copyright (C) 2013 Jolla Ltd.
+ *  Copyright (C) 2014 Jolla 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
@@ -45,9 +45,7 @@
 
 /* Amount of ms we wait between CLCC calls */
 #define POLL_CLCC_INTERVAL 300
-
 #define FLAG_NEED_CLIP 1
-
 #define MAX_DTMF_BUFFER 32
 
 struct voicecall_data {
@@ -86,6 +84,21 @@ struct lastcause_req {
 static void send_one_dtmf(struct voicecall_data *vd);
 static void clear_dtmf_queue(struct voicecall_data *vd);
 
+/*
+ * structs ofono_voicecall and voicecall are fully defined
+ * in src/voicecall.c; we need (read) access to the
+ * call objects, so partially redefine them here.
+ */
+struct ofono_voicecall {
+	GSList *call_list;
+	/* ... */
+};
+
+struct voicecall {
+	struct ofono_call *call;
+	/* ... */
+};
+
 static void lastcause_cb(struct ril_msg *message, gpointer user_data)
 {
 	struct lastcause_req *reqdata = user_data;
@@ -99,11 +112,38 @@ static void lastcause_cb(struct ril_msg *message, gpointer user_data)
 	if (parcel_r_int32(&rilp) > 0)
 		last_cause = parcel_r_int32(&rilp);
 
+	/*
+	 * Not all call control cause values specified in 3GPP TS 24.008
+	 * "Mobile radio interface Layer 3 specification; Core network protocols",
+	 * Annex H, are properly reflected in the RIL API. For example, cause
+	 * #21 "call rejected" is mapped to CALL_FAIL_ERROR_UNSPECIFIED, and
+	 * thus indistinguishable from a network failure.
+	 * We signal disconnect reason "remote" for cause values
+	 *   - #16 "normal call clearing"
+	 *   - #17 "user busy"
+	 *   - UNSPECIFIED for MO calls that are not yet connected
+	 * , and disconnect reason "network" otherwise.
+	 */
 	ofono_info("Call %d ended with RIL cause %d", id, last_cause);
 	if (last_cause == CALL_FAIL_NORMAL || last_cause == CALL_FAIL_BUSY) {
 		reason = OFONO_DISCONNECT_REASON_REMOTE_HANGUP;
 	}
 
+	if (last_cause == CALL_FAIL_ERROR_UNSPECIFIED) {
+		GSList *l;
+		struct voicecall *v;
+		for (l = vc->call_list; l; l = l->next) {
+			v = l->data;
+			if (v->call->id == id) {
+				if (v->call->status == CALL_STATUS_DIALING
+					|| v->call->status == CALL_STATUS_ALERTING) {
+					reason = OFONO_DISCONNECT_REASON_REMOTE_HANGUP;
+				}
+				break;
+			}
+		}
+	}
+
 	ofono_voicecall_disconnected(vc, id, reason, NULL);
 }
 
@@ -236,6 +276,8 @@ static void generic_cb(struct ril_msg *message, gpointer user_data)
 	int request = RIL_REQUEST_GET_CURRENT_CALLS;
 	int ret;
 
+	ofono_info("request:%d",message->req);
+
 	if (message->error == RIL_E_SUCCESS) {
 		decode_ril_error(&error, "OK");
 	} else {
@@ -340,15 +382,17 @@ static void ril_dial(struct ofono_voicecall *vc,
 	struct parcel rilp;
 	int request = RIL_REQUEST_DIAL;
 	int ret;
+	char *phstr = NULL;
 
-	ofono_info("dialing");
+	phstr = (char *) phone_number_to_string(ph);
+	ofono_info("dialing \"%s\"", phstr);
 
 	cbd->user = vc;
 
 	parcel_init(&rilp);
 
 	/* Number to dial */
-        parcel_w_string(&rilp, (char *) phone_number_to_string(ph));
+	parcel_w_string(&rilp, phstr);
 	/* CLIR mode */
 	parcel_w_int32(&rilp, clir);
 	/* USS, need it twice for absent */
@@ -481,6 +525,7 @@ static void ril_ss_notify(struct ril_msg *message, gpointer user_data)
 				strncpy(number.number, tmp_number,
 					OFONO_MAX_PHONE_NUMBER_LENGTH);
 
+			g_free(tmp_number);
 			DBG("RIL data: MT/MO: %i, code: %i, index: %i",
 				notification_type, code, index);
 		break;
@@ -634,6 +679,13 @@ static void ril_create_multiparty(struct ofono_voicecall *vc,
 		cb(&error, data);
 }
 
+static void ril_transfer(struct ofono_voicecall *vc,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	ril_template(RIL_REQUEST_EXPLICIT_CALL_TRANSFER, vc, generic_cb, 0,
+				NULL, 0, cb, data);
+}
+
 static void private_chat_cb(struct ril_msg *message, gpointer user_data)
 {
 	struct ofono_error error;
@@ -727,6 +779,23 @@ static gboolean enable_supp_svc(gpointer user_data)
 	return FALSE;
 }
 
+static void ril_ringback_tone_notify(struct ril_msg *message,
+	gpointer user_data)
+{
+	struct parcel rilp;
+	struct ofono_voicecall *vc = user_data;
+	gboolean playTone = FALSE;
+
+	ril_util_init_parcel(message, &rilp);
+
+	if (message->req == RIL_UNSOL_RINGBACK_TONE) {
+		if (parcel_r_int32(&rilp) > 0)
+			playTone = parcel_r_int32(&rilp);
+		DBG("play ringback tone: %d", playTone);
+		ofono_voicecall_ringback_tone_notify(vc, playTone);
+	}
+}
+
 static gboolean ril_delayed_register(gpointer user_data)
 {
 	struct ofono_voicecall *vc = user_data;
@@ -747,6 +816,10 @@ static gboolean ril_delayed_register(gpointer user_data)
 	g_ril_register(vd->ril, RIL_UNSOL_SUPP_SVC_NOTIFICATION,
 			ril_ss_notify, vc);
 
+	/* Register for ringback tone notifications */
+	g_ril_register(vd->ril, RIL_UNSOL_RINGBACK_TONE,
+			ril_ringback_tone_notify, vc);
+
 	/* request supplementary service notifications*/
 	enable_supp_svc(vc);
 
@@ -803,6 +876,7 @@ static void ril_voicecall_remove(struct ofono_voicecall *vc)
 	if (vd->timer_id > 0)
 		g_source_remove(vd->timer_id);
 
+	g_free(vd->tone_queue);
 	g_ril_unref(vd->ril);
 	g_free(vd);
 }
@@ -817,12 +891,13 @@ static struct ofono_voicecall_driver driver = {
 	.release_specific		= ril_hangup_specific,
 	.send_tones			= ril_send_dtmf,
 	.create_multiparty		= ril_create_multiparty,
+	.transfer			= ril_transfer,
 	.private_chat			= ril_private_chat,
 	.swap_without_accept		= ril_swap_without_accept,
 	.hold_all_active		= ril_hold_all_active,
 	.release_all_held		= ril_release_all_held,
 	.set_udub			= ril_set_udub,
-	.release_all_active	= ril_release_all_active,
+	.release_all_active		= ril_release_all_active,
 };
 
 void ril_voicecall_init(void)

ofono/drivers/telitmodem/location-reporting.c

@@ -0,0 +1,315 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2008-2014  Intel Corporation. All rights reserved.
+ *
+ *  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 <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include <glib.h>
+
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/location-reporting.h>
+
+#include "gatchat.h"
+#include "gatresult.h"
+#include "gattty.h"
+
+#include "telitmodem.h"
+
+static const char *none_prefix[] = { NULL };
+static const char *portcfg_prefix[] = { "#PORTCFG:", NULL };
+static const char *gpsctl_prefix[] = { "$GPSP:", NULL };
+
+struct gps_data {
+	GAtChat *chat;
+};
+
+static void telit_gps_disable_cb(gboolean ok, GAtResult *result,
+							gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	struct ofono_location_reporting *lr = cbd->user;
+	ofono_location_reporting_disable_cb_t cb = cbd->cb;
+
+	DBG("lr=%p, ok=%d", lr, ok);
+
+	if (!ok) {
+		struct ofono_error error;
+
+		decode_at_error(&error, g_at_result_final_response(result));
+		cb(&error, cbd->data);
+
+		return;
+	}
+
+	CALLBACK_WITH_SUCCESS(cb, cbd->data);
+}
+
+static void telit_location_reporting_disable(
+				struct ofono_location_reporting *lr,
+				ofono_location_reporting_disable_cb_t cb,
+				void *data)
+{
+	struct gps_data *gd = ofono_location_reporting_get_data(lr);
+	struct cb_data *cbd = cb_data_new(cb, data);
+
+	DBG("lr=%p", lr);
+
+	cbd->user = lr;
+
+	if (g_at_chat_send(gd->chat, "AT$GPSP=0", none_prefix,
+				telit_gps_disable_cb, cbd, g_free) > 0)
+		return;
+
+	CALLBACK_WITH_FAILURE(cb, data);
+
+	g_free(cbd);
+}
+
+static int enable_data_stream(struct ofono_location_reporting *lr)
+{
+	struct ofono_modem *modem;
+	const char *gps_dev;
+	GHashTable *options;
+	GIOChannel *channel;
+	int fd;
+
+	modem = ofono_location_reporting_get_modem(lr);
+	gps_dev = ofono_modem_get_string(modem, "GPS");
+
+	options = g_hash_table_new(g_str_hash, g_str_equal);
+	if (options == NULL)
+		return -1;
+
+	g_hash_table_insert(options, "Baud", "115200");
+
+	channel = g_at_tty_open(gps_dev, options);
+
+	g_hash_table_destroy(options);
+
+	if (channel == NULL)
+		return -1;
+
+	fd = g_io_channel_unix_get_fd(channel);
+
+	g_io_channel_set_close_on_unref(channel, FALSE);
+	g_io_channel_unref(channel);
+
+	return fd;
+}
+
+static void telit_gps_ctl_cb(gboolean ok, GAtResult *result,
+					gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_location_reporting_enable_cb_t cb = cbd->cb;
+	struct ofono_location_reporting *lr = cbd->user;
+	struct ofono_error error;
+	int fd;
+
+	DBG("lr=%p ok=%d", lr, ok);
+
+	decode_at_error(&error, g_at_result_final_response(result));
+
+	if (!ok) {
+		cb(&error, -1, cbd->data);
+
+		return;
+	}
+
+	fd = enable_data_stream(lr);
+
+	if (fd < 0) {
+		CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
+
+		return;
+	}
+
+	cb(&error, fd, cbd->data);
+	close(fd);
+}
+
+static void telit_gps_enable_cb(gboolean ok, GAtResult *result,
+					gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_location_reporting_enable_cb_t cb = cbd->cb;
+	struct ofono_location_reporting *lr = cbd->user;
+	struct gps_data *gd = ofono_location_reporting_get_data(lr);
+	struct ofono_error error;
+
+	DBG("lr=%p ok=%d", lr, ok);
+
+	decode_at_error(&error, g_at_result_final_response(result));
+
+	if (!ok) {
+		cb(&error, -1, cbd->data);
+
+		g_free(cbd);
+		return;
+	}
+
+	if (g_at_chat_send(gd->chat, "AT$GPSNMUN=1,0,0,0,0,0,0",
+				none_prefix, telit_gps_ctl_cb, cbd, g_free) > 0)
+		return;
+
+	CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
+	g_free(cbd);
+}
+
+static void telit_portcfg_check_cb(gboolean ok, GAtResult *result,
+					gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_location_reporting_enable_cb_t cb = cbd->cb;
+	struct ofono_location_reporting *lr = cbd->user;
+	struct gps_data *gd = ofono_location_reporting_get_data(lr);
+	struct ofono_error error;
+	int requested_portcfg, current_portcfg;
+	GAtResultIter iter;
+
+	DBG("lr=%p ok=%d", lr, ok);
+
+	decode_at_error(&error, g_at_result_final_response(result));
+
+	if (!ok) {
+		cb(&error, -1, cbd->data);
+
+		g_free(cbd);
+		return;
+	}
+
+	g_at_result_iter_init(&iter, result);
+
+	if (!g_at_result_iter_next(&iter, "#PORTCFG:"))
+		goto fail;
+
+	if (!g_at_result_iter_next_number(&iter, &requested_portcfg))
+		goto fail;
+
+	if (!g_at_result_iter_next_number(&iter, &current_portcfg))
+		goto fail;
+
+	if (current_portcfg != 8) {
+		ofono_warn("Unable to start GPS, modem configuration invalid");
+		ofono_warn("Refer to doc/telit-modem.txt section HE910/GPS");
+		goto fail;
+	}
+
+	if (g_at_chat_send(gd->chat, "AT$GPSP=1", none_prefix,
+				telit_gps_enable_cb, cbd, NULL) > 0)
+		return;
+
+fail:
+	CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
+	g_free(cbd);
+}
+
+static void telit_location_reporting_enable(struct ofono_location_reporting *lr,
+					ofono_location_reporting_enable_cb_t cb,
+					void *data)
+{
+	struct gps_data *gd = ofono_location_reporting_get_data(lr);
+	struct cb_data *cbd = cb_data_new(cb, data);
+
+	DBG("lr=%p", lr);
+
+	cbd->user = lr;
+
+	if (g_at_chat_send(gd->chat, "AT#PORTCFG?", portcfg_prefix,
+				telit_portcfg_check_cb, cbd, NULL) > 0)
+		return;
+
+	CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
+	g_free(cbd);
+}
+
+static void telit_location_reporting_support_cb(gboolean ok, GAtResult *result,
+							gpointer user_data)
+{
+	struct ofono_location_reporting *lr = user_data;
+
+	if (!ok) {
+		ofono_location_reporting_remove(lr);
+
+		return;
+	}
+
+	ofono_location_reporting_register(lr);
+}
+
+static int telit_location_reporting_probe(struct ofono_location_reporting *lr,
+						unsigned int vendor, void *data)
+{
+	GAtChat *chat = data;
+	struct gps_data *gd;
+
+	gd = g_try_new0(struct gps_data, 1);
+	if (gd == NULL)
+		return -ENOMEM;
+
+	gd->chat = g_at_chat_clone(chat);
+
+	ofono_location_reporting_set_data(lr, gd);
+
+	g_at_chat_send(gd->chat, "AT$GPSP=?", gpsctl_prefix,
+					telit_location_reporting_support_cb,
+					lr, NULL);
+
+	return 0;
+}
+
+static void telit_location_reporting_remove(struct ofono_location_reporting *lr)
+{
+	struct gps_data *gd = ofono_location_reporting_get_data(lr);
+
+	ofono_location_reporting_set_data(lr, NULL);
+
+	g_at_chat_unref(gd->chat);
+	g_free(gd);
+}
+
+static struct ofono_location_reporting_driver driver = {
+	.name			= "telitmodem",
+	.type			= OFONO_LOCATION_REPORTING_TYPE_NMEA,
+	.probe			= telit_location_reporting_probe,
+	.remove			= telit_location_reporting_remove,
+	.enable			= telit_location_reporting_enable,
+	.disable		= telit_location_reporting_disable,
+};
+
+void telit_location_reporting_init()
+{
+	ofono_location_reporting_driver_register(&driver);
+}
+
+void telit_location_reporting_exit()
+{
+	ofono_location_reporting_driver_unregister(&driver);
+}

ofono/drivers/telitmodem/telitmodem.c

@@ -0,0 +1,49 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+#include <gatchat.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+#include <ofono/plugin.h>
+#include <ofono/types.h>
+
+#include "telitmodem.h"
+
+static int telitmodem_init(void)
+{
+	telit_location_reporting_init();
+
+	return 0;
+}
+
+static void telitmodem_exit(void)
+{
+	telit_location_reporting_exit();
+}
+
+OFONO_PLUGIN_DEFINE(telitmodem, "Telit modem driver", VERSION,
+			OFONO_PLUGIN_PRIORITY_DEFAULT,
+			telitmodem_init, telitmodem_exit)

ofono/drivers/telitmodem/telitmodem.h

@@ -0,0 +1,25 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *
+ *  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
+ *
+ */
+
+#include <drivers/atmodem/atutil.h>
+
+extern void telit_location_reporting_init();
+extern void telit_location_reporting_exit();

ofono/dundee/dundee.service.in

@@ -1,6 +1,7 @@
 [Unit]
 Description=DUN service
-After=syslog.target
+Requires=dbus.service
+After=dbus.service
 
 [Service]
 Type=dbus

ofono/gatchat/gatchat.c

@@ -835,6 +835,9 @@ static gboolean can_write_data(gpointer data)
 	gsize len;
 	char *cr;
 	gboolean wakeup_first = FALSE;
+#ifdef WRITE_SCHEDULER_DEBUG
+	int limiter;
+#endif
 
 	/* Grab the first command off the queue and write as
 	 * much of it as we can
@@ -886,13 +889,20 @@ static gboolean can_write_data(gpointer data)
 		towrite = cr - (cmd->cmd + chat->cmd_bytes_written) + 1;
 
 #ifdef WRITE_SCHEDULER_DEBUG
-	if (towrite > 5)
-		towrite = 5;
+	limiter = towrite;
+
+	if (limiter > 5)
+		limiter = 5;
 #endif
 
 	bytes_written = g_at_io_write(chat->io,
 					cmd->cmd + chat->cmd_bytes_written,
-					towrite);
+#ifdef WRITE_SCHEDULER_DEBUG
+					limiter
+#else
+					towrite
+#endif
+					);
 
 	if (bytes_written == 0)
 		return FALSE;

ofono/gatchat/gatppp.c

@@ -64,11 +64,13 @@ struct _GAtPPP {
 	struct pppcp_data *ipcp;
 	struct ppp_net *net;
 	struct ppp_chap *chap;
+	struct ppp_pap *pap;
 	GAtHDLC *hdlc;
 	gint mru;
 	gint mtu;
 	char username[256];
 	char password[256];
+	GAtPPPAuthMethod auth_method;
 	GAtPPPConnectFunc connect_cb;
 	gpointer connect_data;
 	GAtPPPDisconnectFunc disconnect_cb;
@@ -150,13 +152,15 @@ static inline gboolean ppp_drop_packet(GAtPPP *ppp, guint16 protocol)
 			return TRUE;
 		break;
 	case PPP_PHASE_AUTHENTICATION:
-		if (protocol != LCP_PROTOCOL && protocol != CHAP_PROTOCOL)
+		if (protocol != LCP_PROTOCOL && protocol != CHAP_PROTOCOL &&
+					protocol != PAP_PROTOCOL)
 			return TRUE;
 		break;
 	case PPP_PHASE_DEAD:
 		return TRUE;
 	case PPP_PHASE_NETWORK:
 		if (protocol != LCP_PROTOCOL && protocol != CHAP_PROTOCOL &&
+					protocol != PAP_PROTOCOL &&
 					protocol != IPCP_PROTO)
 			return TRUE;
 		break;
@@ -221,6 +225,13 @@ static void ppp_receive(const unsigned char *buf, gsize len, void *data)
 		break;
 	case IPCP_PROTO:
 		pppcp_process_packet(ppp->ipcp, packet, len - offset);
+		break;
+	case PAP_PROTOCOL:
+		if (ppp->pap)
+			ppp_pap_process_packet(ppp->pap, packet, len - offset);
+		else
+			pppcp_send_protocol_reject(ppp->lcp, buf, len);
+
 		break;
 	case CHAP_PROTOCOL:
 		if (ppp->chap) {
@@ -359,6 +370,12 @@ void ppp_set_auth(GAtPPP *ppp, const guint8* auth_data)
 	guint16 proto = get_host_short(auth_data);
 
 	switch (proto) {
+	case PAP_PROTOCOL:
+		if (ppp->pap)
+			ppp_pap_free(ppp->pap);
+
+		ppp->pap = ppp_pap_new(ppp);
+		break;
 	case CHAP_PROTOCOL:
 		if (ppp->chap)
 			ppp_chap_free(ppp->chap);
@@ -437,10 +454,19 @@ void ppp_ipcp_finished_notify(GAtPPP *ppp)
 
 void ppp_lcp_up_notify(GAtPPP *ppp)
 {
-	/* Wait for the peer to send us a challenge if we expect auth */
 	if (ppp->chap != NULL) {
+		/* Wait for the peer to send us a challenge. */
 		ppp_enter_phase(ppp, PPP_PHASE_AUTHENTICATION);
 		return;
+	} else if (ppp->pap != NULL) {
+		/* Try to send an Authenticate-Request and wait for reply. */
+		if (ppp_pap_start(ppp->pap) == TRUE)
+			ppp_enter_phase(ppp, PPP_PHASE_AUTHENTICATION);
+		else
+			/* It'll never work out. */
+			ppp_auth_notify(ppp, FALSE);
+
+		return;
 	}
 
 	/* Otherwise proceed as if auth succeeded */
@@ -588,6 +614,22 @@ const char *g_at_ppp_get_password(GAtPPP *ppp)
 	return ppp->password;
 }
 
+gboolean g_at_ppp_set_auth_method(GAtPPP *ppp, GAtPPPAuthMethod method)
+{
+	if (method != G_AT_PPP_AUTH_METHOD_CHAP &&
+					method != G_AT_PPP_AUTH_METHOD_PAP)
+		return FALSE;
+
+	ppp->auth_method = method;
+
+	return TRUE;
+}
+
+GAtPPPAuthMethod g_at_ppp_get_auth_method(GAtPPP *ppp)
+{
+	return ppp->auth_method;
+}
+
 void g_at_ppp_set_recording(GAtPPP *ppp, const char *filename)
 {
 	if (ppp == NULL)
@@ -727,6 +769,9 @@ void g_at_ppp_unref(GAtPPP *ppp)
 	else if (ppp->fd >= 0)
 		close(ppp->fd);
 
+	if (ppp->pap)
+		ppp_pap_free(ppp->pap);
+
 	if (ppp->chap)
 		ppp_chap_free(ppp->chap);
 
@@ -794,6 +839,9 @@ static GAtPPP *ppp_init_common(gboolean is_server, guint32 ip)
 	/* initialize IPCP state */
 	ppp->ipcp = ipcp_new(ppp, is_server, ip);
 
+	/* chap authentication by default */
+	ppp->auth_method = G_AT_PPP_AUTH_METHOD_CHAP;
+
 	return ppp;
 }
 

ofono/gatchat/gatppp.h

@@ -43,6 +43,11 @@ typedef enum _GAtPPPDisconnectReason {
 	G_AT_PPP_REASON_LOCAL_CLOSE,	/* Normal user close */
 } GAtPPPDisconnectReason;
 
+typedef enum _GAtPPPAuthMethod {
+	G_AT_PPP_AUTH_METHOD_CHAP,
+	G_AT_PPP_AUTH_METHOD_PAP,
+} GAtPPPAuthMethod;
+
 typedef void (*GAtPPPConnectFunc)(const char *iface, const char *local,
 					const char *peer,
 					const char *dns1, const char *dns2,
@@ -74,6 +79,9 @@ gboolean g_at_ppp_set_credentials(GAtPPP *ppp, const char *username,
 const char *g_at_ppp_get_username(GAtPPP *ppp);
 const char *g_at_ppp_get_password(GAtPPP *ppp);
 
+gboolean g_at_ppp_set_auth_method(GAtPPP *ppp, GAtPPPAuthMethod method);
+GAtPPPAuthMethod g_at_ppp_get_auth_method(GAtPPP *ppp);
+
 void g_at_ppp_set_recording(GAtPPP *ppp, const char *filename);
 
 void g_at_ppp_set_server_info(GAtPPP *ppp, const char *remote_ip,

ofono/gatchat/ppp.h

@@ -22,6 +22,7 @@
 #include "ppp_cp.h"
 
 #define LCP_PROTOCOL	0xc021
+#define PAP_PROTOCOL	0xc023
 #define CHAP_PROTOCOL	0xc223
 #define IPCP_PROTO	0x8021
 #define IPV6CP_PROTO	0x8057
@@ -38,6 +39,7 @@
 
 struct ppp_chap;
 struct ppp_net;
+struct ppp_pap;
 
 struct ppp_header {
 	guint8 address;
@@ -109,6 +111,13 @@ void ppp_chap_free(struct ppp_chap *chap);
 void ppp_chap_process_packet(struct ppp_chap *chap, const guint8 *new_packet,
 				gsize len);
 
+/* PAP related functions */
+struct ppp_pap *ppp_pap_new(GAtPPP *ppp);
+void ppp_pap_free(struct ppp_pap *pap);
+gboolean ppp_pap_start(struct ppp_pap *pap);
+void ppp_pap_process_packet(struct ppp_pap *pap, const guint8 *new_packet,
+				gsize len);
+
 /* TUN / Network related functions */
 struct ppp_net *ppp_net_new(GAtPPP *ppp, int fd);
 const char *ppp_net_get_interface(struct ppp_net *net);

ofono/gatchat/ppp_auth.c

@@ -54,6 +54,38 @@ enum chap_code {
 	FAILURE
 };
 
+struct pap_header {
+	guint8 code;
+	guint8 identifier;
+	guint16 length;
+	guint8 data[0];
+} __attribute__((packed));
+
+struct ppp_pap {
+	GAtPPP *ppp;
+	struct ppp_header *authreq;
+	guint16 authreq_len;
+	guint retry_timer;
+	guint retries;
+};
+
+enum pap_code {
+	PAP_REQUEST = 1,
+	PAP_ACK,
+	PAP_NAK
+};
+
+/*
+ * RFC 1334 2.1.1:
+ *   The Authenticate-Request packet MUST be repeated until a valid
+ *   reply packet is received, or an optional retry counter expires.
+ *
+ * If we don't get a reply after this many attempts, we can safely
+ * assume we're never going to get one.
+ */
+#define PAP_MAX_RETRY	3  /* attempts */
+#define PAP_TIMEOUT	10 /* seconds */
+
 static void chap_process_challenge(struct ppp_chap *chap, const guint8 *packet)
 {
 	const struct chap_header *header = (const struct chap_header *) packet;
@@ -166,3 +198,114 @@ struct ppp_chap *ppp_chap_new(GAtPPP *ppp, guint8 method)
 
 	return chap;
 }
+
+void ppp_pap_process_packet(struct ppp_pap *pap, const guint8 *new_packet,
+				gsize len)
+{
+	guint8 code;
+
+	if (len < sizeof(struct pap_header))
+		return;
+
+	code = new_packet[0];
+
+	switch (code) {
+	case PAP_ACK:
+		g_source_remove(pap->retry_timer);
+		pap->retry_timer = 0;
+		ppp_auth_notify(pap->ppp, TRUE);
+		break;
+	case PAP_NAK:
+		g_source_remove(pap->retry_timer);
+		pap->retry_timer = 0;
+		ppp_auth_notify(pap->ppp, FALSE);
+		break;
+	default:
+		break;
+	}
+}
+
+static gboolean ppp_pap_timeout(gpointer user_data)
+{
+	struct ppp_pap *pap = (struct ppp_pap *)user_data;
+	struct pap_header *authreq;
+
+	if (++pap->retries >= PAP_MAX_RETRY) {
+		pap->retry_timer = 0;
+		ppp_auth_notify(pap->ppp, FALSE);
+		return FALSE;
+	}
+
+	/*
+	 * RFC 1334 2.2.1:
+	 * The Identifier field MUST be changed each time an
+	 * Authenticate-Request packet is issued.
+	 */
+	authreq = (struct pap_header *)&pap->authreq->info;
+	authreq->identifier++;
+
+	ppp_transmit(pap->ppp, (guint8 *)pap->authreq, pap->authreq_len);
+
+	return TRUE;
+}
+
+gboolean ppp_pap_start(struct ppp_pap *pap)
+{
+	struct pap_header *authreq;
+	struct ppp_header *packet;
+	const char *username = g_at_ppp_get_username(pap->ppp);
+	const char *password = g_at_ppp_get_password(pap->ppp);
+	guint16 length;
+
+	length = sizeof(*authreq) + strlen(username) + strlen(password) + 2;
+
+	packet = ppp_packet_new(length, PAP_PROTOCOL);
+	if (packet == NULL)
+		return FALSE;
+
+	pap->authreq = packet;
+	pap->authreq_len = length;
+
+	authreq = (struct pap_header *)&packet->info;
+	authreq->code = PAP_REQUEST;
+	authreq->identifier = 1;
+	authreq->length = htons(length);
+
+	authreq->data[0] = (unsigned char) strlen(username);
+	memcpy(authreq->data + 1, username, strlen(username));
+	authreq->data[strlen(username) + 1] = (unsigned char)strlen(password);
+	memcpy(authreq->data + 1 + strlen(username) + 1, password,
+					strlen(password));
+
+	/* Transmit the packet and schedule a retry. */
+	ppp_transmit(pap->ppp, (guint8 *)packet, length);
+	pap->retries = 0;
+	pap->retry_timer = g_timeout_add_seconds(PAP_TIMEOUT,
+							ppp_pap_timeout, pap);
+
+	return TRUE;
+}
+
+void ppp_pap_free(struct ppp_pap *pap)
+{
+	if (pap->retry_timer != 0)
+		g_source_remove(pap->retry_timer);
+
+	if (pap->authreq != NULL)
+		g_free(pap->authreq);
+
+	g_free(pap);
+}
+
+struct ppp_pap *ppp_pap_new(GAtPPP *ppp)
+{
+	struct ppp_pap *pap;
+
+	pap = g_try_new0(struct ppp_pap, 1);
+	if (pap == NULL)
+		return NULL;
+
+	pap->ppp = ppp;
+
+	return pap;
+}

ofono/gatchat/ppp_lcp.c

@@ -238,25 +238,49 @@ static enum rcr_result lcp_rcr(struct pppcp_data *pppcp,
 			guint8 method = option_data[2];
 			guint8 *option;
 
-			if ((proto == CHAP_PROTOCOL) && (method == MD5))
-				break;
+			switch (g_at_ppp_get_auth_method(ppp)) {
+			case G_AT_PPP_AUTH_METHOD_CHAP:
+				if (proto == CHAP_PROTOCOL && method == MD5)
+					break;
 
-			/*
-			 * try to suggest CHAP & MD5.  If we are out
-			 * of memory, just reject.
-			 */
+				/*
+				 * Try to suggest CHAP/MD5.
+				 * Just reject if we run out of memory.
+				 */
+				option = g_try_malloc0(5);
+				if (option == NULL)
+					return RCR_REJECT;
 
-			option = g_try_malloc0(5);
-			if (option == NULL)
-				return RCR_REJECT;
+				option[0] = AUTH_PROTO;
+				option[1] = 5;
+				put_network_short(&option[2], CHAP_PROTOCOL);
+				option[4] = MD5;
+				*new_options = option;
+				*new_len = 5;
 
-			option[0] = AUTH_PROTO;
-			option[1] = 5;
-			put_network_short(&option[2], CHAP_PROTOCOL);
-			option[4] = MD5;
-			*new_options = option;
-			*new_len = 5;
-			return RCR_NAK;
+				return RCR_NAK;
+
+			case G_AT_PPP_AUTH_METHOD_PAP:
+				if (proto == PAP_PROTOCOL)
+					break;
+
+				/*
+				 * Try to suggest PAP.
+				 * Just reject if we run out of memory.
+				 */
+				option = g_try_malloc0(4);
+				if (option == NULL)
+					return RCR_REJECT;
+
+				option[0] = AUTH_PROTO;
+				option[1] = 4;
+				put_network_short(&option[2], PAP_PROTOCOL);
+				*new_options = option;
+				*new_len = 4;
+
+				return RCR_NAK;
+			}
+			break;
 		}
 		case ACCM:
 		case PFC:

ofono/gdbus/client.c

@@ -51,11 +51,14 @@ struct GDBusClient {
 	GDBusWatchFunction connect_func;
 	void *connect_data;
 	GDBusWatchFunction disconn_func;
+	gboolean connected;
 	void *disconn_data;
 	GDBusMessageFunction signal_func;
 	void *signal_data;
 	GDBusProxyFunction proxy_added;
 	GDBusProxyFunction proxy_removed;
+	GDBusClientFunction ready;
+	void *ready_data;
 	GDBusPropertyFunction property_changed;
 	void *user_data;
 	GList *proxy_list;
@@ -725,6 +728,93 @@ gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy,
 	return TRUE;
 }
 
+gboolean g_dbus_proxy_set_property_array(GDBusProxy *proxy,
+				const char *name, int type, const void *value,
+				size_t size, GDBusResultFunction function,
+				void *user_data, GDBusDestroyFunction destroy)
+{
+	struct set_property_data *data;
+	GDBusClient *client;
+	DBusMessage *msg;
+	DBusMessageIter iter, variant, array;
+	DBusPendingCall *call;
+	char array_sig[3];
+	char type_sig[2];
+
+	if (!proxy || !name || !value)
+		return FALSE;
+
+	if (!dbus_type_is_basic(type))
+		return FALSE;
+
+	client = proxy->client;
+	if (!client)
+		return FALSE;
+
+	data = g_try_new0(struct set_property_data, 1);
+	if (!data)
+		return FALSE;
+
+	data->function = function;
+	data->user_data = user_data;
+	data->destroy = destroy;
+
+	msg = dbus_message_new_method_call(client->service_name,
+						proxy->obj_path,
+						DBUS_INTERFACE_PROPERTIES,
+						"Set");
+	if (!msg) {
+		g_free(data);
+		return FALSE;
+	}
+
+	array_sig[0] = DBUS_TYPE_ARRAY;
+	array_sig[1] = (char) type;
+	array_sig[2] = '\0';
+
+	type_sig[0] = (char) type;
+	type_sig[1] = '\0';
+
+	dbus_message_iter_init_append(msg, &iter);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
+							&proxy->interface);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
+
+	dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
+							array_sig, &variant);
+
+	dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
+							type_sig, &array);
+
+	if (dbus_type_is_fixed(type))
+		dbus_message_iter_append_fixed_array(&array, type, &value,
+									size);
+	else if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH) {
+		const char **str = (const char **) value;
+		size_t i;
+
+		for (i = 0; i < size; i++)
+			dbus_message_iter_append_basic(&array, type, &str[i]);
+	}
+
+	dbus_message_iter_close_container(&variant, &array);
+	dbus_message_iter_close_container(&iter, &variant);
+
+	if (g_dbus_send_message_with_reply(client->dbus_conn, msg,
+							&call, -1) == FALSE) {
+		dbus_message_unref(msg);
+		g_free(data);
+		return FALSE;
+	}
+
+	dbus_pending_call_set_notify(call, set_property_reply, data, g_free);
+	dbus_pending_call_unref(call);
+
+	dbus_message_unref(msg);
+
+	return TRUE;
+}
+
 struct method_call_data {
 	GDBusReturnFunction function;
 	void *user_data;
@@ -982,6 +1072,9 @@ static void parse_managed_objects(GDBusClient *client, DBusMessage *msg)
 
 		dbus_message_iter_next(&dict);
 	}
+
+	if (client->ready)
+		client->ready(client, client->ready_data);
 }
 
 static void get_managed_objects_reply(DBusPendingCall *call, void *user_data)
@@ -1054,6 +1147,8 @@ static void service_connect(DBusConnection *conn, void *user_data)
 
 	get_managed_objects(client);
 
+	client->connected = TRUE;
+
 	g_dbus_client_unref(client);
 }
 
@@ -1064,8 +1159,10 @@ static void service_disconnect(DBusConnection *conn, void *user_data)
 	g_list_free_full(client->proxy_list, proxy_free);
 	client->proxy_list = NULL;
 
-	if (client->disconn_func)
+	if (client->disconn_func) {
 		client->disconn_func(conn, client->disconn_data);
+		client->connected = FALSE;
+	}
 }
 
 static DBusHandlerResult message_filter(DBusConnection *connection,
@@ -1118,6 +1215,7 @@ GDBusClient *g_dbus_client_new(DBusConnection *connection,
 	client->dbus_conn = dbus_connection_ref(connection);
 	client->service_name = g_strdup(service);
 	client->base_path = g_strdup(path);
+	client->connected = FALSE;
 
 	client->match_rules = g_ptr_array_sized_new(1);
 	g_ptr_array_set_free_func(client->match_rules, g_free);
@@ -1192,7 +1290,11 @@ void g_dbus_client_unref(GDBusClient *client)
 
 	g_list_free_full(client->proxy_list, proxy_free);
 
-	if (client->disconn_func)
+	/*
+	 * Don't call disconn_func twice if disconnection
+	 * was previously reported.
+	 */
+	if (client->disconn_func && client->connected)
 		client->disconn_func(client->dbus_conn, client->disconn_data);
 
 	g_dbus_remove_watch(client->dbus_conn, client->watch);
@@ -1243,6 +1345,18 @@ gboolean g_dbus_client_set_signal_watch(GDBusClient *client,
 	return TRUE;
 }
 
+gboolean g_dbus_client_set_ready_watch(GDBusClient *client,
+				GDBusClientFunction ready, void *user_data)
+{
+	if (client == NULL)
+		return FALSE;
+
+	client->ready = ready;
+	client->ready_data = user_data;
+
+	return TRUE;
+}
+
 gboolean g_dbus_client_set_proxy_handlers(GDBusClient *client,
 					GDBusProxyFunction proxy_added,
 					GDBusProxyFunction proxy_removed,

ofono/gdbus/gdbus.h

@@ -329,6 +329,11 @@ gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy,
 				GDBusResultFunction function, void *user_data,
 				GDBusDestroyFunction destroy);
 
+gboolean g_dbus_proxy_set_property_array(GDBusProxy *proxy,
+				const char *name, int type, const void *value,
+				size_t size, GDBusResultFunction function,
+				void *user_data, GDBusDestroyFunction destroy);
+
 typedef void (* GDBusSetupFunction) (DBusMessageIter *iter, void *user_data);
 typedef void (* GDBusReturnFunction) (DBusMessage *message, void *user_data);
 
@@ -337,6 +342,7 @@ gboolean g_dbus_proxy_method_call(GDBusProxy *proxy, const char *method,
 				GDBusReturnFunction function, void *user_data,
 				GDBusDestroyFunction destroy);
 
+typedef void (* GDBusClientFunction) (GDBusClient *client, void *user_data);
 typedef void (* GDBusProxyFunction) (GDBusProxy *proxy, void *user_data);
 typedef void (* GDBusPropertyFunction) (GDBusProxy *proxy, const char *name,
 					DBusMessageIter *iter, void *user_data);
@@ -359,7 +365,8 @@ gboolean g_dbus_client_set_disconnect_watch(GDBusClient *client,
 				GDBusWatchFunction function, void *user_data);
 gboolean g_dbus_client_set_signal_watch(GDBusClient *client,
 				GDBusMessageFunction function, void *user_data);
-
+gboolean g_dbus_client_set_ready_watch(GDBusClient *client,
+				GDBusClientFunction ready, void *user_data);
 gboolean g_dbus_client_set_proxy_handlers(GDBusClient *client,
 					GDBusProxyFunction proxy_added,
 					GDBusProxyFunction proxy_removed,

ofono/gdbus/mainloop.c

@@ -30,8 +30,6 @@
 
 #include "gdbus.h"
 
-#define DISPATCH_TIMEOUT  0
-
 #define info(fmt...)
 #define error(fmt...)
 #define debug(fmt...)
@@ -70,8 +68,6 @@ static gboolean message_dispatch(void *data)
 {
 	DBusConnection *conn = data;
 
-	dbus_connection_ref(conn);
-
 	/* Dispatch messages */
 	while (dbus_connection_dispatch(conn) == DBUS_DISPATCH_DATA_REMAINS);
 
@@ -84,7 +80,7 @@ static inline void queue_dispatch(DBusConnection *conn,
 						DBusDispatchStatus status)
 {
 	if (status == DBUS_DISPATCH_DATA_REMAINS)
-		g_timeout_add(DISPATCH_TIMEOUT, message_dispatch, conn);
+		g_idle_add(message_dispatch, dbus_connection_ref(conn));
 }
 
 static gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data)
@@ -94,13 +90,14 @@ static gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data)
 	DBusDispatchStatus status;
 	DBusConnection *conn;
 
-	conn = dbus_connection_ref(info->conn);
-
 	if (cond & G_IO_IN)  flags |= DBUS_WATCH_READABLE;
 	if (cond & G_IO_OUT) flags |= DBUS_WATCH_WRITABLE;
 	if (cond & G_IO_HUP) flags |= DBUS_WATCH_HANGUP;
 	if (cond & G_IO_ERR) flags |= DBUS_WATCH_ERROR;
 
+	/* Protect connection from being destroyed by dbus_watch_handle */
+	conn = dbus_connection_ref(info->conn);
+
 	dbus_watch_handle(info->watch, flags);
 
 	status = dbus_connection_get_dispatch_status(conn);

ofono/gdbus/object.c

@@ -1088,7 +1088,6 @@ static const GDBusMethodTable introspect_methods[] = {
 static void append_interfaces(struct generic_data *data, DBusMessageIter *iter)
 {
 	DBusMessageIter array;
-	GSList *l;
 
 	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 				DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
@@ -1100,12 +1099,7 @@ static void append_interfaces(struct generic_data *data, DBusMessageIter *iter)
 				DBUS_DICT_ENTRY_END_CHAR_AS_STRING
 				DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array);
 
-	for (l = data->interfaces; l != NULL; l = l->next) {
-		if (g_slist_find(data->added, l->data))
-			continue;
-
-		append_interface(l->data, &array);
-	}
+	g_slist_foreach(data->interfaces, append_interface, &array);
 
 	dbus_message_iter_close_container(iter, &array);
 }
@@ -1253,6 +1247,8 @@ static struct generic_data *object_path_ref(DBusConnection *connection,
 
 	if (!dbus_connection_register_object_path(connection, path,
 						&generic_table, data)) {
+		dbus_connection_unref(data->conn);
+		g_free(data->path);
 		g_free(data->introspect);
 		g_free(data);
 		return NULL;

ofono/gdbus/watch.c

@@ -362,6 +362,7 @@ static void service_data_free(struct service_data *data)
 	callback->data = NULL;
 }
 
+/* Returns TRUE if data is freed */
 static gboolean filter_data_remove_callback(struct filter_data *data,
 						struct filter_callback *cb)
 {
@@ -383,7 +384,7 @@ static gboolean filter_data_remove_callback(struct filter_data *data,
 	/* Don't remove the filter if other callbacks exist or data is lock
 	 * processing callbacks */
 	if (data->callbacks || data->lock)
-		return TRUE;
+		return FALSE;
 
 	if (data->registered && !remove_match(data))
 		return FALSE;
@@ -405,7 +406,9 @@ static DBusHandlerResult signal_filter(DBusConnection *connection,
 
 		if (cb->signal_func && !cb->signal_func(connection, message,
 							cb->user_data)) {
-			filter_data_remove_callback(data, cb);
+			if (filter_data_remove_callback(data, cb))
+				break;
+
 			continue;
 		}
 
@@ -489,7 +492,9 @@ static DBusHandlerResult service_filter(DBusConnection *connection,
 		/* Only auto remove if it is a bus name watch */
 		if (data->argument[0] == ':' &&
 				(cb->conn_func == NULL || cb->disc_func == NULL)) {
-			filter_data_remove_callback(data, cb);
+			if (filter_data_remove_callback(data, cb))
+				break;
+
 			continue;
 		}
 
@@ -586,7 +591,6 @@ static gboolean update_service(void *user_data)
 	struct filter_callback *cb = data->callback;
 	DBusConnection *conn;
 
-	update_name_cache(data->name, data->owner);
 	conn = dbus_connection_ref(data->conn);
 	service_data_free(data);
 
@@ -695,7 +699,8 @@ guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
 	if (name == NULL)
 		return 0;
 
-	data = filter_data_get(connection, service_filter, NULL, NULL,
+	data = filter_data_get(connection, service_filter,
+				DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
 				DBUS_INTERFACE_DBUS, "NameOwnerChanged",
 				name);
 	if (data == NULL)

ofono/gril/gril.c

@@ -51,9 +51,6 @@
 #define COMMAND_FLAG_EXPECT_PDU			0x1
 #define COMMAND_FLAG_EXPECT_SHORT_PROMPT	0x2
 
-#define RILD_CMD_SOCKET "/dev/socket/rild"
-#define RILD_DBG_SOCKET "/dev/socket/rild-debug"
-
 struct ril_request {
 	gchar *data;
 	guint data_len;
@@ -85,6 +82,7 @@ struct ril_s {
 	guint next_cmd_id;			/* Next command id */
 	guint next_notify_id;			/* Next notify id */
 	guint next_gid;				/* Next group id */
+	int sk;					/* Socket */
 	GRilIO *io;				/* GRil IO */
 	GQueue *command_queue;			/* Command queue */
 	GQueue *out_queue;			/* Commands sent/been sent */
@@ -355,7 +353,8 @@ static void handle_response(struct ril_s *p, struct ril_msg *message)
 	int i;
 	guint len, id;
 
-	g_assert(count > 0);
+	if (!count)
+		return;
 
 	for (i = 0; i < count; i++) {
 		req = g_queue_peek_nth(p->command_queue, i);
@@ -373,13 +372,13 @@ static void handle_response(struct ril_s *p, struct ril_msg *message)
 							message->error));
 
 			req = g_queue_pop_nth(p->command_queue, i);
-			if (req->callback) {
+			if (req->callback)
 				req->callback(message, req->user_data);
-			}
 
 			len = g_queue_get_length(p->out_queue);
 			for (i = 0; i < len; i++) {
-				id = *(guint *) g_queue_peek_nth(p->out_queue, i);
+				id = *(guint *) g_queue_peek_nth(
+							p->out_queue, i);
 				if (id == req->id) {
 					g_queue_pop_nth(p->out_queue, i);
 					break;
@@ -403,14 +402,21 @@ static void handle_response(struct ril_s *p, struct ril_msg *message)
 
 }
 
+static void notify_call_callback(gpointer data, gpointer user_data)
+{
+	struct ril_notify_node *node = data;
+	struct ril_msg *message = user_data;
+
+	node->callback(message, node->user_data);
+}
+
 static void handle_unsol_req(struct ril_s *p, struct ril_msg *message)
 {
 	GHashTableIter iter;
 	struct ril_notify *notify;
 	int req_key;
 	gpointer key, value;
-	GList *list_item;
-	struct ril_notify_node *node;
+	GSList *list_item;
 	gboolean found = FALSE;
 
 	if (p->notify_list == NULL)
@@ -430,15 +436,12 @@ static void handle_unsol_req(struct ril_s *p, struct ril_msg *message)
 		if (req_key != message->req)
 			continue;
 
-		list_item = (GList *) notify->nodes;
+		list_item = notify->nodes;
 
-		while (list_item != NULL) {
-			node = list_item->data;
-
-			node->callback(message, node->user_data);
+		if (list_item)
 			found = TRUE;
-			list_item = (GList *) g_slist_next(list_item);
-		}
+
+		g_slist_foreach(notify->nodes, notify_call_callback, message);
 	}
 
 	/* Only log events not being listended for... */
@@ -582,9 +585,8 @@ static void new_bytes(struct ring_buffer *rbuf, gpointer user_data)
 	while (p->suspended == FALSE && (p->read_so_far < len)) {
 		gsize rbytes = MIN(len - p->read_so_far, wrap - p->read_so_far);
 
-		if (rbytes < 4) {
+		if (rbytes < 4)
 			return;
-		}
 
 		/* this function attempts to read the next full length
 		 * fixed message from the stream.  if not all bytes are
@@ -595,9 +597,8 @@ static void new_bytes(struct ring_buffer *rbuf, gpointer user_data)
 		message = read_fixed_record(p, buf, &rbytes);
 
 		/* wait for the rest of the record... */
-		if (message == NULL) {
+		if (message == NULL)
 			break;
-		}
 
 		buf += rbytes;
 		p->read_so_far += rbytes;
@@ -642,7 +643,8 @@ static gboolean can_write_data(gpointer data)
 		for (i = 0; i < qlen; i++) {
 			req = g_queue_peek_nth(ril->command_queue, i);
 			if (req) {
-				id = *(guint *) g_queue_peek_head(ril->out_queue);
+				id = *(guint *) g_queue_peek_head(
+							ril->out_queue);
 				if (req->id == id)
 					goto out;
 			} else {
@@ -782,6 +784,7 @@ static void ril_unref(struct ril_s *ril)
 		g_ril_io_unref(ril->io);
 		ril->io = NULL;
 		ril_cleanup(ril);
+		close(ril->sk);
 	}
 
 	if (ril->in_read_handler)
@@ -801,12 +804,11 @@ static gboolean node_compare_by_group(struct ril_notify_node *node,
 	return FALSE;
 }
 
-static struct ril_s *create_ril()
+static struct ril_s *create_ril(const char *sockpath)
 
 {
 	struct ril_s *ril;
 	struct sockaddr_un addr;
-	int sk;
 	GIOChannel *io;
 	GKeyFile *keyfile;
 	char **subscriptions = NULL;
@@ -814,6 +816,10 @@ static struct ril_s *create_ril()
 	GError *err = NULL;
 	char *path = "/etc/ofono/ril_subscription.conf";
 
+	DBG("sockpath: %s", sockpath);
+	if (!sockpath)
+		return NULL;
+
 	ril = g_try_new0(struct ril_s, 1);
 	if (ril == NULL)
 		return ril;
@@ -827,27 +833,27 @@ static struct ril_s *create_ril()
 	ril->trace = FALSE;
 	ril->connected = FALSE;
 
-	sk = socket(AF_UNIX, SOCK_STREAM, 0);
-	if (sk < 0) {
-		ofono_error("create_ril: can't create unix socket: %s (%d)\n",
-				strerror(errno), errno);
+	ril->sk = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (ril->sk < 0) {
+		ofono_error("%s: can't create unix socket: %s (%d)\n",
+				__func__, strerror(errno), errno);
 		goto error;
 	}
 
 	memset(&addr, 0, sizeof(addr));
 	addr.sun_family = AF_UNIX;
-	strncpy(addr.sun_path, RILD_CMD_SOCKET, sizeof(addr.sun_path) - 1);
+	strncpy(addr.sun_path, sockpath, sizeof(addr.sun_path) - 1);
 
-	if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
-		ofono_error("create_ril: can't connect to RILD: %s (%d)\n",
-				strerror(errno), errno);
+	if (connect(ril->sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+		ofono_error("%s: can't connect to RILD: %s (%d)\n",
+				__func__, strerror(errno), errno);
 		goto error;
 	}
 
-	io = g_io_channel_unix_new(sk);
+	io = g_io_channel_unix_new(ril->sk);
 	if (io == NULL) {
-		ofono_error("create_ril: can't connect to RILD: %s (%d)\n",
-				strerror(errno), errno);
+		ofono_error("%s: can't connect to RILD: %s (%d)\n",
+				__func__, strerror(errno), errno);
 		return NULL;
 	}
 
@@ -856,7 +862,7 @@ static struct ril_s *create_ril()
 
 	ril->io = g_ril_io_new(io);
 	if (ril->io == NULL) {
-		ofono_error("create_ril: can't create ril->io");
+		ofono_error("%s: can't create ril->io", __func__);
 		goto error;
 	}
 
@@ -864,13 +870,13 @@ static struct ril_s *create_ril()
 
 	ril->command_queue = g_queue_new();
 	if (ril->command_queue == NULL) {
-		ofono_error("create_ril: Couldn't create command_queue.");
+		ofono_error("%s: Couldn't create command_queue.", __func__);
 		goto error;
 	}
 
 	ril->out_queue = g_queue_new();
 	if (ril->out_queue == NULL) {
-		ofono_error("create_ril: Couldn't create out_queue.");
+		ofono_error("%s: Couldn't create out_queue.", __func__);
 		goto error;
 	}
 
@@ -900,9 +906,6 @@ static struct ril_s *create_ril()
 		g_strfreev(subscriptions);
 	}
 
-	current_passwd = g_try_malloc(16);
-	if (current_passwd)
-		g_stpcpy(current_passwd, defaultpasswd);
 	current_online_state = RIL_OFFLINE;
 
 	return ril;
@@ -1072,15 +1075,16 @@ void g_ril_init_parcel(struct ril_msg *message, struct parcel *rilp)
 	rilp->offset = 0;
 }
 
-GRil *g_ril_new()
+GRil *g_ril_new(const char *sockpath)
 {
+	DBG("");
 	GRil *ril;
 
 	ril = g_try_new0(GRil, 1);
 	if (ril == NULL)
 		return NULL;
 
-	ril->parent = create_ril();
+	ril->parent = create_ril(sockpath);
 	if (ril->parent == NULL) {
 		g_free(ril);
 		return NULL;

ofono/gril/gril.h

@@ -93,7 +93,7 @@ extern char print_buf[];
 
 void g_ril_init_parcel(struct ril_msg *message, struct parcel *rilp);
 
-GRil *g_ril_new();
+GRil *g_ril_new(const char *sockpath);
 
 GIOChannel *g_ril_get_channel(GRil *ril);
 GRilIO *g_ril_get_io(GRil *ril);
@@ -138,7 +138,6 @@ guint g_ril_register(GRil *ril, const int req,
 gboolean g_ril_unregister(GRil *ril, guint id);
 gboolean g_ril_unregister_all(GRil *ril);
 
-gchar *current_passwd;
 guint current_online_state;
 
 #ifdef __cplusplus

ofono/gril/grilio.c

@@ -73,6 +73,7 @@ static void read_watcher_destroy_notify(gpointer user_data)
 	io->read_handler = NULL;
 	io->read_data = NULL;
 
+	g_io_channel_unref(io->channel);
 	io->channel = NULL;
 
 	if (io->destroyed)

ofono/gril/grilreply.c

@@ -159,19 +159,8 @@ struct reply_setup_data_call *g_ril_reply_parse_data_call(GRil *gril,
 
 	}
 
-	/* TODO:
-	 * RILD can return multiple addresses; oFono only supports
-	 * setting a single IPv4 address.  At this time, we only
-	 * use the first address.  It's possible that a RIL may
-	 * just specify the end-points of the point-to-point
-	 * connection, in which case this code will need to
-	 * changed to handle such a device.
-	 *
-	 * For now split into a maximum of three, and only use
-	 * the first address for the remaining operations.
-	 */
 	if (raw_ip_addrs)
-		reply->ip_addrs = g_strsplit(raw_ip_addrs, " ", 3);
+		reply->ip_addrs = g_strsplit(raw_ip_addrs, " ", -1);
 	else
 		reply->ip_addrs = NULL;
 
@@ -191,7 +180,7 @@ struct reply_setup_data_call *g_ril_reply_parse_data_call(GRil *gril,
 	 * setting a single IPv4 gateway.
 	 */
 	if (raw_gws)
-		reply->gateways = g_strsplit(raw_gws, " ", 3);
+		reply->gateways = g_strsplit(raw_gws, " ", -1);
 	else
 		reply->gateways = NULL;
 
@@ -203,7 +192,7 @@ struct reply_setup_data_call *g_ril_reply_parse_data_call(GRil *gril,
 
 	/* Split DNS addresses */
 	if (dnses)
-		reply->dns_addresses = g_strsplit(dnses, " ", 3);
+		reply->dns_addresses = g_strsplit(dnses, " ", -1);
 	else
 		reply->dns_addresses = NULL;
 

ofono/gril/grilrequest.c

@@ -211,3 +211,24 @@ error:
         OFONO_EINVAL(error);
 	return FALSE;
 }
+
+void g_ril_request_set_uicc_subscription(GRil *gril, int slot_id,
+					int app_index,
+					int sub_id,
+					int sub_status,
+					struct parcel *rilp)
+{
+	parcel_init(rilp);
+
+	parcel_w_int32(rilp, slot_id);
+	parcel_w_int32(rilp, app_index);
+	parcel_w_int32(rilp, sub_id);
+	parcel_w_int32(rilp, sub_status);
+
+	g_ril_append_print_buf(gril, "(%d, %d, %d, %d(%s))",
+				slot_id,
+				app_index,
+				sub_id,
+				sub_status,
+				sub_status ? "ACTIVATE" : "DEACTIVATE");
+}

ofono/gril/grilrequest.h

@@ -56,6 +56,12 @@ gboolean g_ril_request_setup_data_call(GRil *gril,
 					struct parcel *rilp,
 					struct ofono_error *error);
 
+void g_ril_request_set_uicc_subscription(GRil *gril, int slot_id,
+						int app_index,
+						int sub_id,
+						int sub_status,
+						struct parcel *rilp);
+
 #ifdef __cplusplus
 }
 #endif

ofono/gril/grilunsol.c

@@ -77,6 +77,58 @@ void g_ril_unsol_free_data_call_list(struct unsol_data_call_list *unsol)
 	}
 }
 
+gboolean g_ril_unsol_cmp_dcl(struct unsol_data_call_list *current,
+				struct unsol_data_call_list *old,
+				gint cid)
+{
+	GSList *nl,*ol;
+	struct data_call *new_call, *old_call;
+
+	new_call = old_call = NULL;
+	gboolean no_cid = TRUE;
+
+
+	if (!current || !old)
+		return FALSE;
+
+	if (current->num != old->num)
+		return FALSE;
+
+	for (nl = current->call_list; nl; nl = nl->next) {
+		new_call = (struct data_call *) nl->data;
+
+		if (new_call->cid != cid)
+			continue;
+
+		for (ol = old->call_list; ol; ol = ol->next) {
+			old_call = (struct data_call *) ol->data; 
+			if(new_call->cid == old_call->cid) {
+				no_cid = FALSE;
+				break;
+			}
+		}
+		if (no_cid)
+			return FALSE;
+
+		if (new_call->active != old_call->active)
+			return FALSE;
+		if (g_strcmp0(new_call->type,old_call->type))
+			return FALSE;
+		if (g_strcmp0(new_call->ifname,old_call->ifname))
+			return FALSE;
+		if (g_strcmp0(new_call->addresses,old_call->addresses))
+			return FALSE;
+		if (g_strcmp0(new_call->dnses,old_call->dnses))
+			return FALSE;
+		if (g_strcmp0(new_call->gateways,old_call->gateways))
+			return FALSE;
+	}
+	if (no_cid)
+		return FALSE;
+
+	return TRUE;
+}
+
 struct unsol_data_call_list *g_ril_unsol_parse_data_call_list(GRil *gril,
 					struct ril_msg *message,
 					struct ofono_error *error)

ofono/gril/grilunsol.h

@@ -51,6 +51,9 @@ struct data_call {
 
 void g_ril_unsol_free_data_call_list(struct unsol_data_call_list *unsol);
 
+gboolean g_ril_unsol_cmp_dcl(struct unsol_data_call_list *current,
+				struct unsol_data_call_list *old, gint cid);
+
 struct unsol_data_call_list *g_ril_unsol_parse_data_call_list(GRil *gril,
 					struct ril_msg *message,
 					struct ofono_error *error);