gprs: Check GPRS_FLAG_ATTACHED_UPDATE

... in pri_deactivate_callback

This prevents attached state from getting stuck at 0 like this:

1. Context deactivation is initiated over D-Bus, ctx->pending is set
2. Attached becomes FALSE, context is still marked as active
3. Attached becomes TRUE, gprs_attached_update sets GPRS_FLAG_ATTACHED_UPDATE
4. Deactivation completes, attached is 0, driver_attached is 1

Futher network status updates don't call gprs_attached_update because
driver_attached is still 1, so attached is staying 0 until we lose the
data registration again which may not happen for quite a long time.

ofono/drivers/ril/ril_sim_info.c

@@ -57,6 +57,7 @@ struct ril_sim_info_priv {
 	char *sim_spn;
 	char *public_spn;
 	char default_spn[RIL_SIM_DEFAULT_SPN_BUFSIZE];
+	int public_spn_block;
 	struct ofono_sim *sim;
 	struct ril_sim_info_watch state_watch;
 	struct ril_sim_info_watch iccid_watch;
@@ -209,14 +210,18 @@ static void ril_sim_info_set_imsi(struct ril_sim_info *self, const char *imsi)
 static void ril_sim_info_update_public_spn(struct ril_sim_info *self)
 {
 	struct ril_sim_info_priv *priv = self->priv;
-	const char *spn = priv->sim_spn ? priv->sim_spn :
+
+	GASSERT(priv->public_spn_block >= 0);
+	if (!priv->public_spn_block) {
+		const char *spn = priv->sim_spn ? priv->sim_spn :
 				priv->cached_spn ? priv->cached_spn :
 				priv->default_spn;
 
-	if (g_strcmp0(priv->public_spn, spn)) {
-		g_free(priv->public_spn);
-		self->spn = priv->public_spn = g_strdup(spn);
-		ril_sim_info_signal_emit(self, SIGNAL_SPN_CHANGED);
+		if (g_strcmp0(priv->public_spn, spn)) {
+			g_free(priv->public_spn);
+			self->spn = priv->public_spn = g_strdup(spn);
+			ril_sim_info_signal_emit(self, SIGNAL_SPN_CHANGED);
+		}
 	}
 }
 
@@ -226,11 +231,15 @@ static void ril_sim_info_set_cached_spn(struct ril_sim_info *self,
 	struct ril_sim_info_priv *priv = self->priv;
 
 	if (g_strcmp0(priv->cached_spn, spn)) {
-		DBG_(self, "cached spn \"%s\"", spn);
 		g_free(priv->cached_spn);
-		priv->cached_spn = g_strdup(spn);
-		priv->update_imsi_cache = TRUE;
-		ril_sim_info_update_imsi_cache(self);
+		if (spn) {
+			DBG_(self, "cached spn \"%s\"", spn);
+			priv->cached_spn = g_strdup(spn);
+			priv->update_imsi_cache = TRUE;
+			ril_sim_info_update_imsi_cache(self);
+		} else {
+			priv->cached_spn = NULL;
+		}
 		ril_sim_info_update_public_spn(self);
 	}
 }
@@ -505,6 +514,7 @@ void ril_sim_info_set_ofono_sim(struct ril_sim_info *self,
 		struct ril_sim_info_priv *priv = self->priv;
 
 		if (priv->sim != sim) {
+			priv->public_spn_block++;
 			ril_sim_info_watch_remove(&priv->state_watch);
 			ril_sim_info_watch_remove(&priv->iccid_watch);
 			ril_sim_info_watch_remove(&priv->imsi_watch);
@@ -524,9 +534,14 @@ void ril_sim_info_set_ofono_sim(struct ril_sim_info *self,
 				DBG_(self, "attached to sim");
 				ril_sim_info_handle_sim_state(self,
 						ofono_sim_get_state(sim));
+			} else {
+				DBG_(self, "detached from sim");
+				ril_sim_info_update_default_spn(self);
+				ril_sim_info_network_check(self);
 			}
 
-			ril_sim_info_network_check(self);
+			priv->public_spn_block--;
+			ril_sim_info_update_public_spn(self);
 		}
 	}
 }

ofono/drivers/ril/ril_ussd.c

@@ -50,17 +50,15 @@ static struct ril_ussd_cbd *ril_ussd_cbd_new(ofono_ussd_cb_t cb, void *data)
 	return cbd;
 }
 
-static void ril_ussd_cb(GRilIoChannel *io, int status,
+static void ril_ussd_cancel_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);
-	}
+	/* Always report sucessful completion, otherwise ofono may get
+	 * stuck in the USSD_STATE_ACTIVE state */
+	cbd->cb(ril_error_ok(&error), cbd->data);
 }
 
 static void ril_ussd_request(struct ofono_ussd *ussd, int dcs,
@@ -120,7 +118,8 @@ static void ril_ussd_cancel(struct ofono_ussd *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));
+				ril_ussd_cancel_cb, ril_ussd_cbd_free,
+				ril_ussd_cbd_new(cb, data));
 }
 
 static void ril_ussd_notify(GRilIoChannel *io, guint code,
@@ -128,32 +127,32 @@ static void ril_ussd_notify(GRilIoChannel *io, guint code,
 {
 	struct ril_ussd *ud = user_data;
 	GRilIoParser rilp;
-	char *ussd_from_network = NULL;
-	char *type = NULL;
-	int ussdtype = 0;
+	char *type;
+	guint32 n = 0;
 
-	ofono_info("ussd_received");
+	ofono_info("ussd received");
 
 	GASSERT(code == RIL_UNSOL_ON_USSD);
 	grilio_parser_init(&rilp, data, len);
-	grilio_parser_get_uint32(&rilp, NULL);
+	grilio_parser_get_uint32(&rilp, &n);
 	type = grilio_parser_get_utf8(&rilp);
-	ussd_from_network = grilio_parser_get_utf8(&rilp);
 
-	ussdtype = g_ascii_xdigit_value(*type);
+	if (type) {
+		int ussdtype = g_ascii_xdigit_value(*type);
+		char *msg = (n > 1) ? grilio_parser_get_utf8(&rilp) : NULL;
 
-	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);
+		if (msg) {
+			const int msglen = strlen(msg);
+			DBG("ussd length %d", msglen);
+			ofono_ussd_notify(ud->ussd, ussdtype, 0xFF,
+					  (const unsigned char *)msg, msglen);
+			/* msg is freed by core if dcs is 0xFF */
+		} else {
+			ofono_ussd_notify(ud->ussd, ussdtype, 0, NULL, 0);
+		}
+
+		g_free(type);
 	}
-
-	/* 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)
@@ -170,7 +169,7 @@ static gboolean ril_ussd_register(gpointer user_data)
 				ril_ussd_notify, RIL_UNSOL_ON_USSD, ud);
 
 	/* Single-shot */
-	return FALSE;
+	return G_SOURCE_REMOVE;
 }
 
 static int ril_ussd_probe(struct ofono_ussd *ussd, unsigned int vendor,

ofono/drivers/ril/ril_voicecall.c

@@ -650,20 +650,11 @@ static void ril_voicecall_clear_dtmf_queue(struct ril_voicecall *vd)
 	}
 }
 
-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);
+	ril_voicecall_request(RIL_REQUEST_CONFERENCE,
+			vc, 0, NULL, cb, data);
 }
 
 static void ril_voicecall_transfer(struct ofono_voicecall *vc,
@@ -676,14 +667,17 @@ static void ril_voicecall_transfer(struct ofono_voicecall *vc,
 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);
+	struct ofono_error error;
+
+	DBG("Private chat with id %d", id);
 	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);
+
+	ril_voicecall_request(RIL_REQUEST_SEPARATE_CONNECTION,
+			vc, 0, req, NULL, NULL);
 	grilio_request_unref(req);
+	cb(ril_error_ok(&error), data);
 }
 
 static void ril_voicecall_swap_without_accept(struct ofono_voicecall *vc,

ofono/src/call-forwarding.c

@@ -60,6 +60,7 @@ struct ofono_call_forwarding {
 	GSList *cf_conditions[4];
 	int flags;
 	DBusMessage *pending;
+	GSList *pending_get_prop;
 	int query_next;
 	int query_end;
 	struct cf_ss_request *ss_req;
@@ -529,6 +530,14 @@ static DBusMessage *cf_get_properties_reply(DBusMessage *msg,
 	return reply;
 }
 
+static void cf_send_properties(gpointer data, gpointer user_data)
+{
+	DBusMessage *msg = data;
+	DBusMessage *reply = cf_get_properties_reply(msg, user_data);
+
+	__ofono_dbus_pending_reply(&msg, reply);
+}
+
 static void get_query_cf_callback(const struct ofono_error *error, int total,
 			const struct ofono_call_forwarding_condition *list,
 			void *data)
@@ -549,8 +558,9 @@ static void get_query_cf_callback(const struct ofono_error *error, int total,
 	}
 
 	if (cf->query_next == CALL_FORWARDING_TYPE_NOT_REACHABLE) {
-		__ofono_dbus_pending_reply(&cf->pending,
-				cf_get_properties_reply(cf->pending, cf));
+		g_slist_foreach(cf->pending_get_prop, cf_send_properties, cf);
+		g_slist_free(cf->pending_get_prop);
+		cf->pending_get_prop = NULL;
 		return;
 	}
 
@@ -577,11 +587,18 @@ static DBusMessage *cf_get_properties(DBusConnection *conn, DBusMessage *msg,
 	if (cf->driver->query == NULL)
 		return __ofono_error_not_implemented(msg);
 
+	if (cf->pending_get_prop) {
+		/* GetProperties is already in progress */
+		cf->pending_get_prop = g_slist_append(cf->pending_get_prop,
+							dbus_message_ref(msg));
+		return NULL;
+	}
+
 	if (__ofono_call_forwarding_is_busy(cf) ||
 			__ofono_ussd_is_busy(cf->ussd))
 		return __ofono_error_busy(msg);
 
-	cf->pending = dbus_message_ref(msg);
+	cf->pending_get_prop = g_slist_append(NULL, dbus_message_ref(msg));
 	cf->query_next = 0;
 
 	get_query_next_cf_cond(cf);
@@ -1268,7 +1285,7 @@ static void cf_unregister_ss_controls(struct ofono_call_forwarding *cf)
 
 gboolean __ofono_call_forwarding_is_busy(struct ofono_call_forwarding *cf)
 {
-	return cf->pending ? TRUE : FALSE;
+	return cf->pending || cf->pending_get_prop;
 }
 
 static void sim_cfis_read_cb(int ok, int total_length, int record,
@@ -1378,6 +1395,13 @@ static void sim_cphs_cff_read_cb(int ok, int total_length, int record,
 					DBUS_TYPE_BOOLEAN, &cfu_voice);
 }
 
+static void cf_cancel_get_prop(gpointer data)
+{
+	DBusMessage *msg = data;
+
+	__ofono_dbus_pending_reply(&msg, __ofono_error_canceled(msg));
+}
+
 static void call_forwarding_unregister(struct ofono_atom *atom)
 {
 	struct ofono_call_forwarding *cf = __ofono_atom_get_data(atom);
@@ -1385,6 +1409,11 @@ static void call_forwarding_unregister(struct ofono_atom *atom)
 	DBusConnection *conn = ofono_dbus_get_connection();
 	struct ofono_modem *modem = __ofono_atom_get_modem(cf->atom);
 
+	if (cf->pending_get_prop) {
+		g_slist_free_full(cf->pending_get_prop, cf_cancel_get_prop);
+		cf->pending_get_prop = NULL;
+	}
+
 	ofono_modem_remove_interface(modem, OFONO_CALL_FORWARDING_INTERFACE);
 	g_dbus_unregister_interface(conn, path,
 					OFONO_CALL_FORWARDING_INTERFACE);

ofono/src/gprs.c

@@ -135,6 +135,7 @@ struct pri_context {
 	struct ofono_gprs *gprs;
 };
 
+static void gprs_attached_update(struct ofono_gprs *gprs);
 static void gprs_netreg_update(struct ofono_gprs *gprs);
 static void gprs_deactivate_next(struct ofono_gprs *gprs);
 static void write_context_settings(struct ofono_gprs *gprs,
@@ -1133,6 +1134,16 @@ static void pri_deactivate_callback(const struct ofono_error *error, void *data)
 	ofono_dbus_signal_property_changed(conn, ctx->path,
 					OFONO_CONNECTION_CONTEXT_INTERFACE,
 					"Active", DBUS_TYPE_BOOLEAN, &value);
+
+	/*
+	 * If "Attached" property was about to be signalled as TRUE but there
+	 * were still active contexts, try again to signal "Attached" property
+	 * to registered applications after active contexts have been released.
+	 */
+	if (ctx->gprs->flags & GPRS_FLAG_ATTACHED_UPDATE) {
+		ctx->gprs->flags &= ~GPRS_FLAG_ATTACHED_UPDATE;
+		gprs_attached_update(ctx->gprs);
+	}
 }
 
 static DBusMessage *pri_set_apn(struct pri_context *ctx, DBusConnection *conn,

rpm/ofono.spec

@@ -18,7 +18,6 @@ Requires(postun): systemd
 BuildRequires:  pkgconfig(glib-2.0)
 BuildRequires:  pkgconfig(dbus-1)
 BuildRequires:  pkgconfig(libudev) >= 145
-BuildRequires:  pkgconfig(bluez) >= 4.85
 BuildRequires:  pkgconfig(mobile-broadband-provider-info)
 BuildRequires:  pkgconfig(libwspcodec) >= 2.0
 BuildRequires:  pkgconfig(libgrilio) >= 1.0.10