[PATCH 01/11] added Send USSD string maximum length

[PATCH 01/11] added Send USSD string maximum length

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 1109 bytes --]

---
 include/types.h |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

diff --git a/include/types.h b/include/types.h
index 6098cba..e25ff02 100644
--- a/include/types.h
+++ b/include/types.h
@@ -77,6 +77,8 @@ struct ofono_error {
 };
 
 #define OFONO_MAX_PHONE_NUMBER_LENGTH 20
+#define OFONO_MAX_USSD_LENGTH 160
+
 
 struct ofono_phone_number {
 	char number[OFONO_MAX_PHONE_NUMBER_LENGTH + 1];
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

[PATCH 02/11] Changes done as per the changed driver API

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 5261 bytes --]

---
 drivers/atmodem/ussd.c |   87 +++++++++++++++++++++++++++++------------------
 1 files changed, 54 insertions(+), 33 deletions(-)

diff --git a/drivers/atmodem/ussd.c b/drivers/atmodem/ussd.c
index 1e1fc25..c386fcd 100644
--- a/drivers/atmodem/ussd.c
+++ b/drivers/atmodem/ussd.c
@@ -56,11 +56,12 @@ static void cusd_parse(GAtResult *result, struct ofono_ussd *ussd)
 	int status;
 	int dcs;
 	const char *content;
-	char *converted = NULL;
 	gboolean udhi;
 	enum sms_charset charset;
 	gboolean compressed;
 	gboolean iso639;
+	unsigned char *msg = NULL;
+	int msg_len = 0;
 
 	g_at_result_iter_init(&iter, result);
 
@@ -83,24 +84,15 @@ static void cusd_parse(GAtResult *result, struct ofono_ussd *ussd)
 	} else
 		charset = SMS_CHARSET_7BIT;
 
-	if (charset == SMS_CHARSET_7BIT)
-		converted = convert_gsm_to_utf8((const guint8 *) content,
-						strlen(content), NULL, NULL, 0);
-
-	else if (charset == SMS_CHARSET_8BIT) {
-		/* TODO: Figure out what to do with 8 bit data */
-		ofono_error("8-bit coded USSD response received");
-		status = 4; /* Not supported */
-	} else {
-		/* No other encoding is mentioned in TS27007 7.15 */
-		ofono_error("Unsupported USSD data coding scheme (%02x)", dcs);
-		status = 4; /* Not supported */
+ out:
+	if (content){
+		msg = g_memdup(content, strlen(content));
+		msg_len = strlen(content);
 	}
 
-out:
-	ofono_ussd_notify(ussd, status, converted);
+	ofono_ussd_notify(ussd, status, dcs, msg, msg_len);
 
-	g_free(converted);
+	g_free(msg);
 }
 
 static void cusd_request_cb(gboolean ok, GAtResult *result, gpointer user_data)
@@ -117,47 +109,76 @@ static void cusd_request_cb(gboolean ok, GAtResult *result, gpointer user_data)
 	cusd_parse(result, ussd);
 }
 
-static void at_ussd_request(struct ofono_ussd *ussd, const char *str,
-				ofono_ussd_cb_t cb, void *user_data)
+static void at_ussd_request(struct ofono_ussd *ussd, int dcs,
+                            const unsigned char *str, int str_len,
+                            ofono_ussd_cb_t cb, void *user_data)
 {
 	struct ussd_data *data = ofono_ussd_get_data(ussd);
 	struct cb_data *cbd = cb_data_new(cb, user_data);
+	int dcs_value = 0x0f;  // GSM 7 bit default alphabet
 	unsigned char *converted = NULL;
-	int dcs;
-	int max_len;
+	unsigned char *coded_str = NULL;
+	long coded_str_len;
+	long num_packed;
 	long written;
 	char buf[256];
+	char *encoded_data = NULL;
 
 	if (!cbd)
 		goto error;
 
 	cbd->user = ussd;
 
-	converted = convert_utf8_to_gsm(str, strlen(str), NULL, &written, 0);
+	if (dcs == -1){
+		converted = convert_utf8_to_gsm((const char *) str, str_len, NULL, &written, 0);
+	
+		if (!converted)
+			goto error;
+
+		/* As per 3GPP TS 23.038, When this character set is used,
+		 * the characters of the message are packed in octets as shown in section 6.1.2.1.1,
+		 * and the message can consist of up to 160 characters.
+		 */
+
+		coded_str = pack_7bit(converted, written, 0, TRUE,
+		                      &num_packed, 0);
+
+		g_free(converted);
+		converted = NULL;
+		coded_str_len = written;
+	}else{
+		coded_str = g_memdup(str, str_len);
+		coded_str_len = str_len;
+		dcs_value = dcs;
+	}
 
-	if (!converted)
+	if (!coded_str)
 		goto error;
-	else {
-		dcs = 15;
-		max_len = 182;
-	}
 
-	if (written > max_len)
+	if (coded_str_len > OFONO_MAX_USSD_LENGTH)
+		goto error;
+
+	encoded_data = encode_hex(coded_str, coded_str_len, 0 );
+
+	if (!encoded_data)
 		goto error;
 
 	snprintf(buf, sizeof(buf), "AT+CUSD=1,\"%.*s\",%d",
-			(int) written, converted, dcs);
+        	 strlen(encoded_data), encoded_data, dcs_value);
+
+	g_free(encoded_data);
+	encoded_data = NULL;
 
-	g_free(converted);
-	converted = NULL;
+	g_free(coded_str);
+	coded_str = NULL;
 
 	if (data->vendor == OFONO_VENDOR_QUALCOMM_MSM) {
 		/* Ensure that the modem is using GSM character set. It
-		 * seems it defaults to IRA and then umlauts are not
+ 		 * seems it defaults to IRA and then umlauts are not
 		 * properly encoded. The modem returns some weird from
 		 * of Latin-1, but it is not really Latin-1 either. */
 		g_at_chat_send(data->chat, "AT+CSCS=\"GSM\"", none_prefix,
-							NULL, NULL, NULL);
+					NULL, NULL, NULL);
 	}
 
 	if (g_at_chat_send(data->chat, buf, cusd_prefix,
@@ -166,7 +187,7 @@ static void at_ussd_request(struct ofono_ussd *ussd, const char *str,
 
 error:
 	g_free(cbd);
-	g_free(converted);
+	g_free(coded_str);
 
 	CALLBACK_WITH_FAILURE(cb, user_data);
 }
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

[PATCH 03/11] __ofono_call_barring_is_busy internal api for STK-Send USSD

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 1342 bytes --]

---
 src/call-barring.c |    5 +++++
 1 files changed, 5 insertions(+), 0 deletions(-)

diff --git a/src/call-barring.c b/src/call-barring.c
index 7607f3f..b58499a 100644
--- a/src/call-barring.c
+++ b/src/call-barring.c
@@ -580,6 +580,11 @@ static void cb_unregister_ss_controls(struct ofono_call_barring *cb)
 	__ofono_ussd_passwd_unregister(cb->ussd, "353");
 }
 
+gboolean __ofono_call_barring_is_busy( struct ofono_call_barring *cb)
+{
+	return cb->pending ? TRUE: FALSE;
+}
+
 static inline void cb_append_property(struct ofono_call_barring *cb,
 					DBusMessageIter *dict, int start,
 					int end, int cls, const char *property)
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

[PATCH 04/11] __ofono_call_forwarding_is_busy internal api for STK-Send USSD

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 1344 bytes --]

---
 src/call-forwarding.c |    5 +++++
 1 files changed, 5 insertions(+), 0 deletions(-)

diff --git a/src/call-forwarding.c b/src/call-forwarding.c
index 4e77144..b3ca6a1 100644
--- a/src/call-forwarding.c
+++ b/src/call-forwarding.c
@@ -1092,6 +1092,11 @@ static void cf_unregister_ss_controls(struct ofono_call_forwarding *cf)
 	__ofono_ussd_ssc_unregister(cf->ussd, "004");
 }
 
+gboolean __ofono_call_forwarding_is_busy( struct ofono_call_forwarding *cf)
+{
+	return cf->pending ? TRUE: FALSE;
+}
+
 int ofono_call_forwarding_driver_register(const struct ofono_call_forwarding_driver *d)
 {
 	DBG("driver: %p, name: %s", d, d->name);
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

[PATCH 05/11] __ofono_call_settings_is_busy internal api for STK-Send USSD

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 1303 bytes --]

---
 src/call-settings.c |    5 +++++
 1 files changed, 5 insertions(+), 0 deletions(-)

diff --git a/src/call-settings.c b/src/call-settings.c
index ab20062..e8c7248 100644
--- a/src/call-settings.c
+++ b/src/call-settings.c
@@ -778,6 +778,11 @@ static void cs_unregister_ss_controls(struct ofono_call_settings *cs)
 		__ofono_ussd_ssc_unregister(cs->ussd, "77");
 }
 
+gboolean __ofono_call_settings_is_busy( struct ofono_call_settings *cs)
+{
+	return cs->pending ? TRUE: FALSE;
+}
+
 static DBusMessage *generate_get_properties_reply(struct ofono_call_settings *cs,
 							DBusMessage *msg)
 {
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

[PATCH 06/11] Send USSD proactive command handling

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 5158 bytes --]

---
 src/stk.c |  115 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 115 insertions(+), 0 deletions(-)

diff --git a/src/stk.c b/src/stk.c
index 3fda2af..66a98b4 100644
--- a/src/stk.c
+++ b/src/stk.c
@@ -1590,6 +1590,117 @@ static gboolean handle_command_set_up_call(const struct stk_command *cmd,
 	return FALSE;
 }
 
+static void send_ussd_callback( int error, int dcs, const unsigned char* msg,
+                                int msg_len, void* userdata)
+{
+	struct ofono_stk *stk = userdata;
+	struct ofono_error failure = { .type = OFONO_ERROR_TYPE_FAILURE };
+	struct stk_response rsp;
+
+	if (stk->pending_cmd->send_ussd.alpha_id &&
+		stk->pending_cmd->send_ussd.alpha_id[0])
+		stk_alpha_id_unset(stk);
+
+	switch (error) {
+	case OFONO_USSD_FAILURE_NONE:
+		memset(&rsp, 0, sizeof(rsp));
+
+		rsp.result.type = STK_RESULT_TYPE_SUCCESS;
+
+		rsp.send_ussd.dcs = dcs;
+		rsp.send_ussd.text = g_memdup(msg, msg_len);
+
+		if (stk_respond(stk, &rsp, stk_command_cb))
+		        stk_command_cb(&failure, stk);
+
+		break;
+	case OFONO_USSD_FAILURE_USER_TERMINATED:
+		send_simple_response(stk, STK_RESULT_TYPE_USSD_OR_SS_USER_TERMINATION);
+		break;
+	case OFONO_USSD_FAILURE_TIMED_OUT:
+		send_simple_response(stk, STK_RESULT_TYPE_NETWORK_UNAVAILABLE);
+		break;
+	case OFONO_USSD_FAILURE_RETURN_ERROR:
+		send_simple_response(stk, STK_RESULT_TYPE_USSD_RETURN_ERROR);
+		break;
+	}
+}
+
+static gboolean handle_command_send_ussd(const struct stk_command *cmd,
+                                        struct stk_response *rsp,
+                                        struct ofono_stk *stk)
+{
+	struct ofono_modem *modem = __ofono_atom_get_modem(stk->atom);
+	static unsigned char busy_on_ss_result[] = { 0x03 };
+	static unsigned char busy_on_ussd_result[] = { 0x08 };
+	int err;
+
+	struct ofono_atom *cf_atom;
+	struct ofono_atom *cb_atom;
+	struct ofono_atom *cs_atom;
+	struct ofono_atom *ussd_atom;
+
+	struct ofono_call_forwarding *cf;
+	struct ofono_call_barring *cb;
+	struct ofono_call_settings *cs;
+	struct ofono_ussd *ussd;
+
+	cf_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_CALL_FORWARDING);
+	cb_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_CALL_BARRING);
+	cs_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_CALL_SETTINGS);
+	ussd_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_USSD);
+
+	if (!cf_atom || !__ofono_atom_get_registered(cf_atom) ||
+		!cb_atom || !__ofono_atom_get_registered(cb_atom) ||
+		!cs_atom || !__ofono_atom_get_registered(cs_atom)) {
+	
+		rsp->result.type = STK_RESULT_TYPE_NOT_CAPABLE;
+		return TRUE;
+	}
+
+	cf = __ofono_atom_get_data(cf_atom);
+	cb = __ofono_atom_get_data(cb_atom);
+	cs = __ofono_atom_get_data(cs_atom);
+	ussd = __ofono_atom_get_data(ussd_atom);
+
+	if (__ofono_call_barring_is_busy(cb) ||
+		__ofono_call_forwarding_is_busy(cf) ||
+		__ofono_call_settings_is_busy(cs)){
+		
+		rsp->result.type = STK_RESULT_TYPE_TERMINAL_BUSY;
+		rsp->result.additional_len = sizeof(busy_on_ss_result);
+		rsp->result.additional = busy_on_ss_result;
+		return TRUE;
+	}
+
+	if (__ofono_ussd_is_busy(ussd)){
+		rsp->result.type = STK_RESULT_TYPE_TERMINAL_BUSY;
+		rsp->result.additional_len = sizeof(busy_on_ussd_result);
+		rsp->result.additional = busy_on_ussd_result;
+		return TRUE;
+	}
+
+	err = __ofono_ussd_initiate( ussd, cmd->send_ussd.ussd_string.dcs,
+                         cmd->send_ussd.ussd_string.string,
+                         cmd->send_ussd.ussd_string.len,
+                         send_ussd_callback, stk);
+
+	if (err >= 0) {
+		return FALSE;
+	}
+
+	if (err == -ENOSYS) {
+		rsp->result.type = STK_RESULT_TYPE_NOT_CAPABLE;
+
+		return TRUE;
+	}
+
+	if (cmd->send_ussd.alpha_id && cmd->send_ussd.alpha_id[0])
+		stk_alpha_id_set(stk, cmd->send_ussd.alpha_id);
+
+	return FALSE;
+}
+
 static void stk_proactive_command_cancel(struct ofono_stk *stk)
 {
 	if (stk->immediate_response)
@@ -1740,6 +1851,10 @@ void ofono_stk_proactive_command_notify(struct ofono_stk *stk,
 		respond = handle_command_set_up_call(stk->pending_cmd,
 							&rsp, stk);
 		break;
+	case STK_COMMAND_TYPE_SEND_USSD:
+		respond = handle_command_send_ussd(stk->pending_cmd,
+                                           &rsp, stk);
+		break;
 
 	default:
 		rsp.result.type = STK_RESULT_TYPE_COMMAND_NOT_UNDERSTOOD;
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

[PATCH 07/11] added stk_response_text_string for USSD result

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 2170 bytes --]

---
 src/stkutil.h |    8 ++++++++
 1 files changed, 8 insertions(+), 0 deletions(-)

diff --git a/src/stkutil.h b/src/stkutil.h
index 44d167a..66d2e55 100644
--- a/src/stkutil.h
+++ b/src/stkutil.h
@@ -237,6 +237,7 @@ enum stk_result_type {
 	STK_RESULT_TYPE_GO_BACK =			0x11,
 	STK_RESULT_TYPE_NO_RESPONSE =			0x12,
 	STK_RESULT_TYPE_HELP_REQUESTED =		0x13,
+	STK_RESULT_TYPE_USSD_OR_SS_USER_TERMINATION =   0x14,
 
 	/* 0x20 to 0x2F are used to indicate that SIM should retry */
 	STK_RESULT_TYPE_TERMINAL_BUSY =			0x20,
@@ -254,6 +255,7 @@ enum stk_result_type {
 	STK_RESULT_TYPE_DATA_NOT_UNDERSTOOD =		0x32,
 	STK_RESULT_TYPE_COMMAND_ID_UNKNOWN =		0x33,
 	STK_RESULT_TYPE_MINIMUM_NOT_MET =		0x36,
+	STK_RESULT_TYPE_USSD_RETURN_ERROR =             0x37,
 	STK_RESULT_TYPE_CALL_CONTROL_PERMANENT =	0x39,
 	STK_RESULT_TYPE_BIP_ERROR =			0x3A,
 	STK_RESULT_TYPE_ACCESS_TECHNOLOGY_ERROR =	0x3B,
@@ -1445,6 +1447,11 @@ struct stk_response_run_at_command {
 	const char *at_response;
 };
 
+struct stk_response_text_string {
+	unsigned char dcs;
+	const unsigned char *text;
+};
+
 struct stk_response {
 	unsigned char number;
 	unsigned char type;
@@ -1474,6 +1481,7 @@ struct stk_response {
 		struct stk_response_generic send_dtmf;
 		struct stk_response_generic language_notification;
 		struct stk_response_generic launch_browser;
+		struct stk_response_text_string send_ussd;
 	};
 
 	void (*destructor)(struct stk_response *response);
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

[PATCH 08/11] STK:Send USSD internal apis

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 3043 bytes --]

---
 src/ofono.h |   26 ++++++++++++++++++++++++++
 1 files changed, 26 insertions(+), 0 deletions(-)

diff --git a/src/ofono.h b/src/ofono.h
index d95f2f2..43368d5 100644
--- a/src/ofono.h
+++ b/src/ofono.h
@@ -163,9 +163,18 @@ gboolean __ofono_modem_remove_atom_watch(struct ofono_modem *modem,
 void __ofono_atom_free(struct ofono_atom *atom);
 
 #include <ofono/call-barring.h>
+
+gboolean __ofono_call_barring_is_busy(struct ofono_call_barring *cb);
+
 #include <ofono/call-forwarding.h>
+
+gboolean __ofono_call_forwarding_is_busy(struct ofono_call_forwarding *cf);
+
 #include <ofono/call-meter.h>
 #include <ofono/call-settings.h>
+
+gboolean __ofono_call_settings_is_busy(struct ofono_call_settings *cs);
+
 #include <ofono/cbs.h>
 #include <ofono/devinfo.h>
 #include <ofono/phonebook.h>
@@ -235,6 +244,13 @@ gboolean __ofono_ssn_mt_watch_remove(struct ofono_ssn *ssn, int id);
 
 #include <ofono/ussd.h>
 
+enum ofono_ussd_failure{
+	OFONO_USSD_FAILURE_NONE = 0x0,
+	OFONO_USSD_FAILURE_USER_TERMINATED,
+	OFONO_USSD_FAILURE_RETURN_ERROR,
+	OFONO_USSD_FAILURE_TIMED_OUT,
+};
+
 typedef gboolean (*ofono_ussd_ssc_cb_t)(int type,
 					const char *sc,
 					const char *sia, const char *sib,
@@ -245,6 +261,10 @@ typedef gboolean (*ofono_ussd_passwd_cb_t)(const char *sc,
 					const char *old, const char *new,
 					DBusMessage *msg, void *data);
 
+typedef void (*ofono_ussd_request_cb_t)(int error, int dcs,
+                                        const unsigned char *str,
+                                        int str_len, void *data);
+
 gboolean __ofono_ussd_ssc_register(struct ofono_ussd *ussd, const char *sc,
 					ofono_ussd_ssc_cb_t cb, void *data,
 					ofono_destroy_func destroy);
@@ -255,6 +275,12 @@ gboolean __ofono_ussd_passwd_register(struct ofono_ussd *ussd, const char *sc,
 					ofono_destroy_func destroy);
 void __ofono_ussd_passwd_unregister(struct ofono_ussd *ussd, const char *sc);
 
+gboolean __ofono_ussd_is_busy(struct ofono_ussd *ussd);
+
+int __ofono_ussd_initiate(struct ofono_ussd *ussd, int dcs,
+                          const unsigned char *str, int str_len,
+                          ofono_ussd_request_cb_t cb, void *user_data);
+
 #include <ofono/netreg.h>
 
 typedef void (*ofono_netreg_status_notify_cb_t)(int status, int lac, int ci,
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

[PATCH 09/11] Driver API changed to accept DCS and any format string

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 1797 bytes --]

---
 include/ussd.h |    8 +++++---
 1 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/include/ussd.h b/include/ussd.h
index 96e04cb..e3b43f7 100644
--- a/include/ussd.h
+++ b/include/ussd.h
@@ -45,13 +45,15 @@ struct ofono_ussd_driver {
 	const char *name;
 	int (*probe)(struct ofono_ussd *ussd, unsigned int vendor, void *data);
 	void (*remove)(struct ofono_ussd *ussd);
-	void (*request)(struct ofono_ussd *ussd, const char *str,
-				ofono_ussd_cb_t, void *data);
+	void (*request)(struct ofono_ussd *ussd, int dcs,
+                    const unsigned char *str, int str_len,
+                    ofono_ussd_cb_t, void *data);
 	void (*cancel)(struct ofono_ussd *ussd,
 				ofono_ussd_cb_t cb, void *data);
 };
 
-void ofono_ussd_notify(struct ofono_ussd *ussd, int status, const char *str);
+void ofono_ussd_notify(struct ofono_ussd *ussd, int status, int dcs,
+                       const unsigned char *str, int str_len);
 
 int ofono_ussd_driver_register(const struct ofono_ussd_driver *d);
 void ofono_ussd_driver_unregister(const struct ofono_ussd_driver *d);
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

[PATCH 10/11] Changes done as per the changed driver API

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 4219 bytes --]

---
 drivers/isimodem/ussd.c |   56 ++++++++++++++++++++++++++++------------------
 1 files changed, 34 insertions(+), 22 deletions(-)

diff --git a/drivers/isimodem/ussd.c b/drivers/isimodem/ussd.c
index d164d10..7ed81f5 100644
--- a/drivers/isimodem/ussd.c
+++ b/drivers/isimodem/ussd.c
@@ -74,7 +74,9 @@ static void ussd_parse(struct ofono_ussd *ussd, const void *restrict data,
 {
 	const unsigned char *msg = data;
 	int status = OFONO_USSD_STATUS_NOT_SUPPORTED;
-	char *converted = NULL;
+	int msg_len = 0;
+	int dcs = -1;
+	unsigned char *coded_msg = NULL;
 
 	if (!msg || len < 4)
 		goto out;
@@ -84,14 +86,12 @@ static void ussd_parse(struct ofono_ussd *ussd, const void *restrict data,
 	if (msg[3] == 0 || (size_t)(msg[3] + 4) > len)
 		goto out;
 
-	converted = ussd_decode(msg[1], msg[3], msg + 4);
-
-	if (converted)
-		status = OFONO_USSD_STATUS_NOTIFY;
-
+	dcs = msg[1];
+	msg_len = msg[3];
+	coded_msg = g_memdup(msg+4, msg_len);
 out:
-	ofono_ussd_notify(ussd, status, converted);
-	g_free(converted);
+	ofono_ussd_notify(ussd, status, dcs, coded_msg, msg_len);
+	g_free(coded_msg);
 }
 
 
@@ -130,8 +130,8 @@ out:
 	return TRUE;
 }
 
-static GIsiRequest *ussd_send_make(GIsiClient *client, uint8_t *str,
-					size_t len, void *data)
+static GIsiRequest *ussd_send_make(GIsiClient *client, int dcs, uint8_t *str,
+                    size_t len, void *data)
 {
 	const uint8_t msg[] = {
 		SS_GSM_USSD_SEND_REQ,
@@ -139,7 +139,7 @@ static GIsiRequest *ussd_send_make(GIsiClient *client, uint8_t *str,
 		0x01,		/* subblock count */
 		SS_GSM_USSD_STRING,
 		4 + len + 3,	/* subblock length */
-		0x0f,		/* DCS */
+		dcs,		/* DCS */
 		len,		/* string length */
 		/* USSD string goes here */
 	};
@@ -153,8 +153,9 @@ static GIsiRequest *ussd_send_make(GIsiClient *client, uint8_t *str,
 					ussd_send_resp_cb, data);
 }
 
-static void isi_request(struct ofono_ussd *ussd, const char *str,
-				ofono_ussd_cb_t cb, void *data)
+static void isi_request(struct ofono_ussd *ussd, int dcs,
+                        const unsigned char *str, int str_len,
+                        ofono_ussd_cb_t cb, void *data)
 {
 	struct ussd_data *ud = ofono_ussd_get_data(ussd);
 	struct isi_cb_data *cbd = isi_cb_data_new(ussd, cb, data);
@@ -163,24 +164,35 @@ static void isi_request(struct ofono_ussd *ussd, const char *str,
 	unsigned char *converted = NULL;
 	long num_packed;
 	long written;
+	int dcs_value = 0x0f; // GSM 7 bit default alphabet
 
 	if (!cbd)
 		goto error;
 
-	converted = convert_utf8_to_gsm(str, strlen(str), NULL, &written, 0);
-	if (!converted)
-		goto error;
+	if (dcs == -1){
+		converted = convert_utf8_to_gsm((const char *) str, str_len, NULL, &written, 0);
 
-	packed = pack_7bit_own_buf(converted, written, 0, TRUE,
-					&num_packed, 0, buf);
+		if (!converted)
+			goto error;
 
-	g_free(converted);
+		packed = pack_7bit_own_buf(converted, written, 0, TRUE,
+				&num_packed, 0, buf);
 
-	if (written > SS_MAX_USSD_LENGTH)
+		g_free(converted);
+
+		if (written > SS_MAX_USSD_LENGTH)
 		goto error;
 
-	if (ussd_send_make(ud->client, packed, num_packed, cbd))
-		return;
+		if (ussd_send_make(ud->client, dcs_value, packed, num_packed, cbd))
+			return;
+	}else{
+		dcs_value = dcs;
+		if (str_len > SS_MAX_USSD_LENGTH)
+			goto error;
+
+		if (ussd_send_make(ud->client, dcs_value, (guint8 *) str, str_len, cbd))
+			return;
+    	}
 
 error:
 	CALLBACK_WITH_FAILURE(cb, data);
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

[PATCH 11/11] __ofono_ussd_initiate internal api for STK-Send USSD

[Jeevaka Badrappan]

[-- Attachment #1: Type: text/plain, Size: 7848 bytes --]

---
 src/ussd.c |  125 ++++++++++++++++++++++++++++++++++++++++++++++++++++--------
 1 files changed, 109 insertions(+), 16 deletions(-)

diff --git a/src/ussd.c b/src/ussd.c
index 825d560..1441044 100644
--- a/src/ussd.c
+++ b/src/ussd.c
@@ -34,6 +34,7 @@
 #include "ofono.h"
 
 #include "common.h"
+#include "smsutil.h"
 
 #define SUPPLEMENTARY_SERVICES_INTERFACE "org.ofono.SupplementaryServices"
 
@@ -46,6 +47,15 @@ enum ussd_state {
 	USSD_STATE_RESPONSE_SENT,
 };
 
+struct ussd_request {
+	struct ofono_ussd *ussd;
+	int dcs;
+	unsigned char *str;
+	int str_len;
+	ofono_ussd_request_cb_t cb;
+	void *user_data;
+};
+
 struct ofono_ussd {
 	int state;
 	DBusMessage *pending;
@@ -56,6 +66,7 @@ struct ofono_ussd {
 	const struct ofono_ussd_driver *driver;
 	void *driver_data;
 	struct ofono_atom *atom;
+	struct ussd_request *req;
 };
 
 struct ssc_entry {
@@ -306,15 +317,55 @@ static void ussd_change_state(struct ofono_ussd *ussd, int state)
 			"State", DBUS_TYPE_STRING, &value);
 }
 
-void ofono_ussd_notify(struct ofono_ussd *ussd, int status, const char *str)
+static void ussd_request_finish(struct ofono_ussd *ussd, int error, int dcs,
+                                const unsigned char *str, int str_len)
+{
+	struct ussd_request *req = ussd->req;
+
+	if (req && req->cb){
+		req->cb(error, dcs, str, str_len, req->user_data);
+		g_free(req->str);
+		g_free(req);
+		ussd->req = NULL;
+	}
+}
+
+static int ussd_status_to_failure_code(int status)
+{
+	switch (status) {
+	case OFONO_USSD_STATUS_TIMED_OUT:
+		return OFONO_USSD_FAILURE_TIMED_OUT;
+	case OFONO_USSD_STATUS_NOT_SUPPORTED:
+		return OFONO_USSD_FAILURE_RETURN_ERROR;
+	}
+
+	return OFONO_USSD_FAILURE_NONE;
+}
+
+void ofono_ussd_notify(struct ofono_ussd *ussd, int status, int dcs,
+                       const unsigned char *str, int str_len)
 {
 	DBusConnection *conn = ofono_dbus_get_connection();
 	const char *ussdstr = "USSD";
+	const char *utf8_str = NULL;
 	const char sig[] = { DBUS_TYPE_STRING, 0 };
 	DBusMessage *reply;
 	DBusMessageIter iter;
 	DBusMessageIter variant;
 
+	if (ussd->req &&
+		(status == OFONO_USSD_STATUS_NOTIFY ||
+		status == OFONO_USSD_STATUS_TERMINATED ||
+		status == OFONO_USSD_STATUS_TIMED_OUT ||
+		status == OFONO_USSD_STATUS_NOT_SUPPORTED)){
+
+		ussd_request_finish(ussd, ussd_status_to_failure_code(status),
+                		    dcs, str, str_len);
+
+		ussd_change_state(ussd, USSD_STATE_IDLE);
+		return;
+	}
+
 	if (status == OFONO_USSD_STATUS_NOT_SUPPORTED) {
 		ussd_change_state(ussd, USSD_STATE_IDLE);
 
@@ -335,14 +386,13 @@ void ofono_ussd_notify(struct ofono_ussd *ussd, int status, const char *str)
 		goto out;
 	}
 
+	utf8_str = str ? ussd_decode(dcs, str_len, str) : "";
+
 	/* TODO: Rework this in the Agent framework */
 	if (ussd->state == USSD_STATE_ACTIVE) {
 
 		reply = dbus_message_new_method_return(ussd->pending);
 
-		if (!str)
-			str = "";
-
 		dbus_message_iter_init_append(reply, &iter);
 
 		dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
@@ -352,7 +402,7 @@ void ofono_ussd_notify(struct ofono_ussd *ussd, int status, const char *str)
 							&variant);
 
 		dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING,
-						&str);
+                                       &utf8_str);
 
 		dbus_message_iter_close_container(&iter, &variant);
 
@@ -364,11 +414,8 @@ void ofono_ussd_notify(struct ofono_ussd *ussd, int status, const char *str)
 	} else if (ussd->state == USSD_STATE_RESPONSE_SENT) {
 		reply = dbus_message_new_method_return(ussd->pending);
 
-		if (!str)
-			str = "";
-
-		dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
-						DBUS_TYPE_INVALID);
+		dbus_message_append_args(reply, DBUS_TYPE_STRING, &utf8_str,
+				DBUS_TYPE_INVALID);
 
 		if (status == OFONO_USSD_STATUS_ACTION_REQUIRED)
 			ussd_change_state(ussd, USSD_STATE_USER_ACTION);
@@ -387,9 +434,6 @@ void ofono_ussd_notify(struct ofono_ussd *ussd, int status, const char *str)
 			signal_name = "NotificationReceived";
 		}
 
-		if (!str)
-			str = "";
-
 		g_dbus_emit_signal(conn, path,
 				SUPPLEMENTARY_SERVICES_INTERFACE, signal_name,
 				DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID);
@@ -436,6 +480,8 @@ static DBusMessage *ussd_initiate(DBusConnection *conn, DBusMessage *msg,
 {
 	struct ofono_ussd *ussd = data;
 	const char *str;
+	int dcs = -1;
+
 
 	if (ussd->pending)
 		return __ofono_error_busy(msg);
@@ -465,7 +511,8 @@ static DBusMessage *ussd_initiate(DBusConnection *conn, DBusMessage *msg,
 
 	ussd->pending = dbus_message_ref(msg);
 
-	ussd->driver->request(ussd, str, ussd_callback, ussd);
+	ussd->driver->request(ussd, dcs, (const guint8*) str, strlen(str), 
+                          ussd_callback, ussd);
 
 	return NULL;
 }
@@ -496,6 +543,7 @@ static DBusMessage *ussd_respond(DBusConnection *conn, DBusMessage *msg,
 {
 	struct ofono_ussd *ussd = data;
 	const char *str;
+	int dcs = -1;
 
 	if (ussd->pending)
 		return __ofono_error_busy(msg);
@@ -515,7 +563,8 @@ static DBusMessage *ussd_respond(DBusConnection *conn, DBusMessage *msg,
 
 	ussd->pending = dbus_message_ref(msg);
 
-	ussd->driver->request(ussd, str, ussd_response_callback, ussd);
+	ussd->driver->request(ussd, dcs, (const guint8*) str, strlen(str),
+                          ussd_response_callback, ussd);
 
 	return NULL;
 }
@@ -543,7 +592,10 @@ static void ussd_cancel_callback(const struct ofono_error *error, void *data)
 	reply = dbus_message_new_method_return(ussd->cancel);
 	__ofono_dbus_pending_reply(&ussd->cancel, reply);
 
-	ussd_change_state(ussd, USSD_STATE_IDLE);
+    if (ussd->req)
+        ussd_request_finish(ussd, -1, USSD_STATE_USER_ACTION, NULL, -1);
+
+    ussd_change_state(ussd, USSD_STATE_IDLE);
 }
 
 static DBusMessage *ussd_cancel(DBusConnection *conn, DBusMessage *msg,
@@ -741,3 +793,44 @@ void *ofono_ussd_get_data(struct ofono_ussd *ussd)
 {
 	return ussd->driver_data;
 }
+
+static void ussd_request_callback(const struct ofono_error *error, void *data)
+{
+	struct ofono_ussd *ussd = data;
+
+	if (error->type != OFONO_ERROR_TYPE_NO_ERROR)
+		ussd_request_finish(ussd, OFONO_USSD_FAILURE_RETURN_ERROR, -1, NULL, -1);
+	else
+		ussd_change_state(ussd,USSD_STATE_ACTIVE);
+}
+
+gboolean __ofono_ussd_is_busy(struct ofono_ussd *ussd)
+{
+	if (ussd->pending || ussd->state != USSD_STATE_IDLE || ussd->req)
+		return TRUE;
+	return FALSE;
+}
+
+int __ofono_ussd_initiate(struct ofono_ussd *ussd, int dcs,
+                          const unsigned char *str, int str_len,
+                          ofono_ussd_request_cb_t cb, void *user_data)
+{
+	struct ussd_request *req;
+
+	if (!ussd->driver->request)
+		return -ENOSYS;
+
+	req = g_try_new0(struct ussd_request, 1);
+	req->dcs = dcs;
+	req->str = g_memdup(str, str_len);
+	req->str_len = str_len;
+	req->cb = cb;
+	req->user_data = user_data;
+
+	ussd->req = req;
+
+	ussd->driver->request(ussd, dcs, str, str_len, ussd_request_callback,
+        	          ussd);
+
+	return 0;
+}
-- 
1.7.0.4



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

Re: [PATCH 02/11] Changes done as per the changed driver API

[Pekka Pessi]

[-- Attachment #1: Type: text/plain, Size: 2376 bytes --]

Hi Jeevaka,

2010/9/1 Jeevaka Badrappan <jeevaka.badrappan@elektrobit.com>:
> ---
>  drivers/atmodem/ussd.c |   87 +++++++++++++++++++++++++++++------------------
>  1 files changed, 54 insertions(+), 33 deletions(-)
>
> diff --git a/drivers/atmodem/ussd.c b/drivers/atmodem/ussd.c
> index 1e1fc25..c386fcd 100644
> --- a/drivers/atmodem/ussd.c
> +++ b/drivers/atmodem/ussd.c
> @@ -56,11 +56,12 @@ static void cusd_parse(GAtResult *result, struct ofono_ussd *ussd)
>        int status;
>        int dcs;
>        const char *content;
> -       char *converted = NULL;
>        gboolean udhi;
>        enum sms_charset charset;
>        gboolean compressed;
>        gboolean iso639;
> +       unsigned char *msg = NULL;
> +       int msg_len = 0;
>
>        g_at_result_iter_init(&iter, result);
>
> @@ -83,24 +84,15 @@ static void cusd_parse(GAtResult *result, struct ofono_ussd *ussd)
>        } else
>                charset = SMS_CHARSET_7BIT;
>
> -       if (charset == SMS_CHARSET_7BIT)
> -               converted = convert_gsm_to_utf8((const guint8 *) content,
> -                                               strlen(content), NULL, NULL, 0);
> -
> -       else if (charset == SMS_CHARSET_8BIT) {
> -               /* TODO: Figure out what to do with 8 bit data */
> -               ofono_error("8-bit coded USSD response received");
> -               status = 4; /* Not supported */
> -       } else {
> -               /* No other encoding is mentioned in TS27007 7.15 */
> -               ofono_error("Unsupported USSD data coding scheme (%02x)", dcs);
> -               status = 4; /* Not supported */
> + out:
> +       if (content){
> +               msg = g_memdup(content, strlen(content));
> +               msg_len = strlen(content);
>        }
>
> -out:
> -       ofono_ussd_notify(ussd, status, converted);
> +       ofono_ussd_notify(ussd, status, dcs, msg, msg_len);

I thought the modem already unpacks the ussd message to 8-bit gsm and
the dcs parameter is rather meaningless in that case. Perhaps the
atmodem ussd should re-pack the string in order to achieve the desired
symmetry on the API?

-- 
Pekka.Pessi mail at nokia.com

Re: [PATCH 02/11] Changes done as per the changed driver API

[Andrzej Zaborowski]

[-- Attachment #1: Type: text/plain, Size: 4583 bytes --]

Hi,

On 1 September 2010 13:00, Jeevaka Badrappan
<jeevaka.badrappan@elektrobit.com> wrote:
> ---
>  drivers/atmodem/ussd.c |   87 +++++++++++++++++++++++++++++------------------
>  1 files changed, 54 insertions(+), 33 deletions(-)
>
> diff --git a/drivers/atmodem/ussd.c b/drivers/atmodem/ussd.c
> index 1e1fc25..c386fcd 100644
> --- a/drivers/atmodem/ussd.c
> +++ b/drivers/atmodem/ussd.c
> @@ -56,11 +56,12 @@ static void cusd_parse(GAtResult *result, struct ofono_ussd *ussd)
>        int status;
>        int dcs;
>        const char *content;
> -       char *converted = NULL;
>        gboolean udhi;
>        enum sms_charset charset;
>        gboolean compressed;
>        gboolean iso639;
> +       unsigned char *msg = NULL;
> +       int msg_len = 0;
>
>        g_at_result_iter_init(&iter, result);
>
> @@ -83,24 +84,15 @@ static void cusd_parse(GAtResult *result, struct ofono_ussd *ussd)
>        } else
>                charset = SMS_CHARSET_7BIT;
>
> -       if (charset == SMS_CHARSET_7BIT)
> -               converted = convert_gsm_to_utf8((const guint8 *) content,
> -                                               strlen(content), NULL, NULL, 0);
> -
> -       else if (charset == SMS_CHARSET_8BIT) {
> -               /* TODO: Figure out what to do with 8 bit data */
> -               ofono_error("8-bit coded USSD response received");
> -               status = 4; /* Not supported */
> -       } else {
> -               /* No other encoding is mentioned in TS27007 7.15 */
> -               ofono_error("Unsupported USSD data coding scheme (%02x)", dcs);
> -               status = 4; /* Not supported */
> + out:
> +       if (content){
> +               msg = g_memdup(content, strlen(content));
> +               msg_len = strlen(content);
>        }
>
> -out:
> -       ofono_ussd_notify(ussd, status, converted);
> +       ofono_ussd_notify(ussd, status, dcs, msg, msg_len);
>
> -       g_free(converted);
> +       g_free(msg);
>  }

I agree with Pekka that maybe this should repack the 7-bit messages
into packed 7-bit, as this is what STK will be expecting in response
(I think).  Also, why are we g_memdup'ing the content instead of using
directly?

>
>  static void cusd_request_cb(gboolean ok, GAtResult *result, gpointer user_data)
> @@ -117,47 +109,76 @@ static void cusd_request_cb(gboolean ok, GAtResult *result, gpointer user_data)
>        cusd_parse(result, ussd);
>  }
>
> -static void at_ussd_request(struct ofono_ussd *ussd, const char *str,
> -                               ofono_ussd_cb_t cb, void *user_data)
> +static void at_ussd_request(struct ofono_ussd *ussd, int dcs,
> +                            const unsigned char *str, int str_len,
> +                            ofono_ussd_cb_t cb, void *user_data)
>  {
>        struct ussd_data *data = ofono_ussd_get_data(ussd);
>        struct cb_data *cbd = cb_data_new(cb, user_data);
> +       int dcs_value = 0x0f;  // GSM 7 bit default alphabet
>        unsigned char *converted = NULL;
> -       int dcs;
> -       int max_len;
> +       unsigned char *coded_str = NULL;
> +       long coded_str_len;
> +       long num_packed;
>        long written;
>        char buf[256];
> +       char *encoded_data = NULL;
>
>        if (!cbd)
>                goto error;
>
>        cbd->user = ussd;
>
> -       converted = convert_utf8_to_gsm(str, strlen(str), NULL, &written, 0);
> +       if (dcs == -1){
> +               converted = convert_utf8_to_gsm((const char *) str, str_len, NULL, &written, 0);
> +
> +               if (!converted)
> +                       goto error;
> +
> +               /* As per 3GPP TS 23.038, When this character set is used,
> +                * the characters of the message are packed in octets as shown in section 6.1.2.1.1,
> +                * and the message can consist of up to 160 characters.
> +                */
> +
> +               coded_str = pack_7bit(converted, written, 0, TRUE,
> +                                     &num_packed, 0);

You could use pack_7bit_own_buf here too.

Please check the style doc about spaces after/before {}.

Best regards

Re: [PATCH 03/11] __ofono_call_barring_is_busy internal api for STK-Send USSD

[Denis Kenzior]

[-- Attachment #1: Type: text/plain, Size: 1149 bytes --]

Hi Jeevaka,

On 09/01/2010 06:00 AM, Jeevaka Badrappan wrote:
> ---
>  src/call-barring.c |    5 +++++
>  1 files changed, 5 insertions(+), 0 deletions(-)
> 
> diff --git a/src/call-barring.c b/src/call-barring.c
> index 7607f3f..b58499a 100644
> --- a/src/call-barring.c
> +++ b/src/call-barring.c
> @@ -580,6 +580,11 @@ static void cb_unregister_ss_controls(struct ofono_call_barring *cb)
>  	__ofono_ussd_passwd_unregister(cb->ussd, "353");
>  }
>  
> +gboolean __ofono_call_barring_is_busy( struct ofono_call_barring *cb)
> +{
> +	return cb->pending ? TRUE: FALSE;
> +}
> +
>  static inline void cb_append_property(struct ofono_call_barring *cb,
>  					DBusMessageIter *dict, int start,
>  					int end, int cls, const char *property)

The rule of thumb for patch submissions is to:
- Make sure all related chunks are together in one patch
- Chunks are only related to the particular change being described
- Unless impossible / extremely hard, the code should compile after each
individual patch.

In this case, please merge the chunks from patch #8 related to call
barring into this patch.

Regards,
-Denis

Re: [PATCH 04/11] __ofono_call_forwarding_is_busy internal api for STK-Send USSD

[Denis Kenzior]

[-- Attachment #1: Type: text/plain, Size: 827 bytes --]

Hi Jeevaka,

On 09/01/2010 06:00 AM, Jeevaka Badrappan wrote:
> ---
>  src/call-forwarding.c |    5 +++++
>  1 files changed, 5 insertions(+), 0 deletions(-)
> 
> diff --git a/src/call-forwarding.c b/src/call-forwarding.c
> index 4e77144..b3ca6a1 100644
> --- a/src/call-forwarding.c
> +++ b/src/call-forwarding.c
> @@ -1092,6 +1092,11 @@ static void cf_unregister_ss_controls(struct ofono_call_forwarding *cf)
>  	__ofono_ussd_ssc_unregister(cf->ussd, "004");
>  }
>  
> +gboolean __ofono_call_forwarding_is_busy( struct ofono_call_forwarding *cf)
> +{
> +	return cf->pending ? TRUE: FALSE;
> +}
> +
>  int ofono_call_forwarding_driver_register(const struct ofono_call_forwarding_driver *d)
>  {
>  	DBG("driver: %p, name: %s", d, d->name);

And same here again, please add chunks from patch #8 here.

Re: [PATCH 07/11] added stk_response_text_string for USSD result

[Denis Kenzior]

[-- Attachment #1: Type: text/plain, Size: 1936 bytes --]

Hi Jeevaka,

On 09/01/2010 06:00 AM, Jeevaka Badrappan wrote:
> ---
>  src/stkutil.h |    8 ++++++++
>  1 files changed, 8 insertions(+), 0 deletions(-)
> 
> diff --git a/src/stkutil.h b/src/stkutil.h
> index 44d167a..66d2e55 100644
> --- a/src/stkutil.h
> +++ b/src/stkutil.h
> @@ -237,6 +237,7 @@ enum stk_result_type {
>  	STK_RESULT_TYPE_GO_BACK =			0x11,
>  	STK_RESULT_TYPE_NO_RESPONSE =			0x12,
>  	STK_RESULT_TYPE_HELP_REQUESTED =		0x13,
> +	STK_RESULT_TYPE_USSD_OR_SS_USER_TERMINATION =   0x14,
>  
>  	/* 0x20 to 0x2F are used to indicate that SIM should retry */
>  	STK_RESULT_TYPE_TERMINAL_BUSY =			0x20,
> @@ -254,6 +255,7 @@ enum stk_result_type {
>  	STK_RESULT_TYPE_DATA_NOT_UNDERSTOOD =		0x32,
>  	STK_RESULT_TYPE_COMMAND_ID_UNKNOWN =		0x33,
>  	STK_RESULT_TYPE_MINIMUM_NOT_MET =		0x36,
> +	STK_RESULT_TYPE_USSD_RETURN_ERROR =             0x37,
>  	STK_RESULT_TYPE_CALL_CONTROL_PERMANENT =	0x39,
>  	STK_RESULT_TYPE_BIP_ERROR =			0x3A,
>  	STK_RESULT_TYPE_ACCESS_TECHNOLOGY_ERROR =	0x3B,
> @@ -1445,6 +1447,11 @@ struct stk_response_run_at_command {
>  	const char *at_response;
>  };
>  
> +struct stk_response_text_string {
> +	unsigned char dcs;
> +	const unsigned char *text;
> +};
> +

3GPP 31.111 says that the terminal response to Send USSD should contain
a simple Text String.  The DCS of the text string in STK is different
from DCS that is returned by USSD.  Copying it directly from the USSD
DCS seems incorrect.  Or is there something I'm missing?

>  struct stk_response {
>  	unsigned char number;
>  	unsigned char type;
> @@ -1474,6 +1481,7 @@ struct stk_response {
>  		struct stk_response_generic send_dtmf;
>  		struct stk_response_generic language_notification;
>  		struct stk_response_generic launch_browser;
> +		struct stk_response_text_string send_ussd;
>  	};
>  
>  	void (*destructor)(struct stk_response *response);

Regards,
-Denis

Re: [PATCH 06/11] Send USSD proactive command handling

[Denis Kenzior]

[-- Attachment #1: Type: text/plain, Size: 407 bytes --]

Hi Jeevaka,

On 09/01/2010 06:00 AM, Jeevaka Badrappan wrote:
> ---
>  src/stk.c |  115 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  1 files changed, 115 insertions(+), 0 deletions(-)
> 
> diff --git a/src/stk.c b/src/stk.c
> index 3fda2af..66a98b4 100644
> --- a/src/stk.c

Since this patch uses structures from patch 7, it should come after
patch 7...

Regards,
-Denis

Re: [PATCH 09/11] Driver API changed to accept DCS and any format string

[Denis Kenzior]

[-- Attachment #1: Type: text/plain, Size: 1449 bytes --]

Hi Jeevaka,

On 09/01/2010 06:00 AM, Jeevaka Badrappan wrote:
> ---
>  include/ussd.h |    8 +++++---
>  1 files changed, 5 insertions(+), 3 deletions(-)
> 
> diff --git a/include/ussd.h b/include/ussd.h
> index 96e04cb..e3b43f7 100644
> --- a/include/ussd.h
> +++ b/include/ussd.h
> @@ -45,13 +45,15 @@ struct ofono_ussd_driver {
>  	const char *name;
>  	int (*probe)(struct ofono_ussd *ussd, unsigned int vendor, void *data);
>  	void (*remove)(struct ofono_ussd *ussd);
> -	void (*request)(struct ofono_ussd *ussd, const char *str,
> -				ofono_ussd_cb_t, void *data);
> +	void (*request)(struct ofono_ussd *ussd, int dcs,
> +                    const unsigned char *str, int str_len,
> +                    ofono_ussd_cb_t, void *data);
>  	void (*cancel)(struct ofono_ussd *ussd,
>  				ofono_ussd_cb_t cb, void *data);
>  };
>  
> -void ofono_ussd_notify(struct ofono_ussd *ussd, int status, const char *str);
> +void ofono_ussd_notify(struct ofono_ussd *ussd, int status, int dcs,
> +                       const unsigned char *str, int str_len);
>  
>  int ofono_ussd_driver_register(const struct ofono_ussd_driver *d);
>  void ofono_ussd_driver_unregister(const struct ofono_ussd_driver *d);

This patch modifies the driver API.  All driver changes resulting from
this patch should follow after this patch.  I'd move this patch to slot
#2 and patch #2 and #10 should come right after.

Regards,
-Denis

Re: [PATCH 06/11] Send USSD proactive command handling

[andrzej zaborowski]

[-- Attachment #1: Type: text/plain, Size: 3802 bytes --]

On 1 September 2010 13:00, Jeevaka Badrappan
<jeevaka.badrappan@elektrobit.com> wrote:
> ---
>  src/stk.c |  115 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  1 files changed, 115 insertions(+), 0 deletions(-)
>
> diff --git a/src/stk.c b/src/stk.c
> index 3fda2af..66a98b4 100644
> --- a/src/stk.c
> +++ b/src/stk.c
> @@ -1590,6 +1590,117 @@ static gboolean handle_command_set_up_call(const struct stk_command *cmd,
>        return FALSE;
>  }
>
> +static void send_ussd_callback( int error, int dcs, const unsigned char* msg,
> +                                int msg_len, void* userdata)
> +{
> +       struct ofono_stk *stk = userdata;
> +       struct ofono_error failure = { .type = OFONO_ERROR_TYPE_FAILURE };
> +       struct stk_response rsp;
> +
> +       if (stk->pending_cmd->send_ussd.alpha_id &&
> +               stk->pending_cmd->send_ussd.alpha_id[0])
> +               stk_alpha_id_unset(stk);
> +
> +       switch (error) {
> +       case OFONO_USSD_FAILURE_NONE:
> +               memset(&rsp, 0, sizeof(rsp));
> +
> +               rsp.result.type = STK_RESULT_TYPE_SUCCESS;
> +
> +               rsp.send_ussd.dcs = dcs;
> +               rsp.send_ussd.text = g_memdup(msg, msg_len);
> +
> +               if (stk_respond(stk, &rsp, stk_command_cb))
> +                       stk_command_cb(&failure, stk);
> +
> +               break;
> +       case OFONO_USSD_FAILURE_USER_TERMINATED:
> +               send_simple_response(stk, STK_RESULT_TYPE_USSD_OR_SS_USER_TERMINATION);
> +               break;
> +       case OFONO_USSD_FAILURE_TIMED_OUT:
> +               send_simple_response(stk, STK_RESULT_TYPE_NETWORK_UNAVAILABLE);
> +               break;
> +       case OFONO_USSD_FAILURE_RETURN_ERROR:
> +               send_simple_response(stk, STK_RESULT_TYPE_USSD_RETURN_ERROR);
> +               break;
> +       }
> +}
> +
> +static gboolean handle_command_send_ussd(const struct stk_command *cmd,
> +                                        struct stk_response *rsp,
> +                                        struct ofono_stk *stk)
> +{
> +       struct ofono_modem *modem = __ofono_atom_get_modem(stk->atom);
> +       static unsigned char busy_on_ss_result[] = { 0x03 };
> +       static unsigned char busy_on_ussd_result[] = { 0x08 };
> +       int err;
> +
> +       struct ofono_atom *cf_atom;
> +       struct ofono_atom *cb_atom;
> +       struct ofono_atom *cs_atom;
> +       struct ofono_atom *ussd_atom;
> +
> +       struct ofono_call_forwarding *cf;
> +       struct ofono_call_barring *cb;
> +       struct ofono_call_settings *cs;
> +       struct ofono_ussd *ussd;
> +
> +       cf_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_CALL_FORWARDING);
> +       cb_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_CALL_BARRING);
> +       cs_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_CALL_SETTINGS);
> +       ussd_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_USSD);
> +
> +       if (!cf_atom || !__ofono_atom_get_registered(cf_atom) ||
> +               !cb_atom || !__ofono_atom_get_registered(cb_atom) ||
> +               !cs_atom || !__ofono_atom_get_registered(cs_atom)) {
> +
> +               rsp->result.type = STK_RESULT_TYPE_NOT_CAPABLE;
> +               return TRUE;
> +       }

Should this return "not capable" only when !ussd_atom?  If the other
atoms are missing I think we can assume they're not occupied.

Best regards

Re: [PATCH 07/11] added stk_response_text_string for USSD result

[andrzej zaborowski]

[-- Attachment #1: Type: text/plain, Size: 2376 bytes --]

Hi Jeevaka,

On 1 September 2010 17:33, Denis Kenzior <denkenz@gmail.com> wrote:
> On 09/01/2010 06:00 AM, Jeevaka Badrappan wrote:
>> ---
>>  src/stkutil.h |    8 ++++++++
>>  1 files changed, 8 insertions(+), 0 deletions(-)
>>
>> diff --git a/src/stkutil.h b/src/stkutil.h
>> index 44d167a..66d2e55 100644
>> --- a/src/stkutil.h
>> +++ b/src/stkutil.h
>> @@ -237,6 +237,7 @@ enum stk_result_type {
>>       STK_RESULT_TYPE_GO_BACK =                       0x11,
>>       STK_RESULT_TYPE_NO_RESPONSE =                   0x12,
>>       STK_RESULT_TYPE_HELP_REQUESTED =                0x13,
>> +     STK_RESULT_TYPE_USSD_OR_SS_USER_TERMINATION =   0x14,
>>
>>       /* 0x20 to 0x2F are used to indicate that SIM should retry */
>>       STK_RESULT_TYPE_TERMINAL_BUSY =                 0x20,
>> @@ -254,6 +255,7 @@ enum stk_result_type {
>>       STK_RESULT_TYPE_DATA_NOT_UNDERSTOOD =           0x32,
>>       STK_RESULT_TYPE_COMMAND_ID_UNKNOWN =            0x33,
>>       STK_RESULT_TYPE_MINIMUM_NOT_MET =               0x36,
>> +     STK_RESULT_TYPE_USSD_RETURN_ERROR =             0x37,
>>       STK_RESULT_TYPE_CALL_CONTROL_PERMANENT =        0x39,
>>       STK_RESULT_TYPE_BIP_ERROR =                     0x3A,
>>       STK_RESULT_TYPE_ACCESS_TECHNOLOGY_ERROR =       0x3B,
>> @@ -1445,6 +1447,11 @@ struct stk_response_run_at_command {
>>       const char *at_response;
>>  };
>>
>> +struct stk_response_text_string {
>> +     unsigned char dcs;
>> +     const unsigned char *text;
>> +};
>> +
>
> 3GPP 31.111 says that the terminal response to Send USSD should contain
> a simple Text String.  The DCS of the text string in STK is different
> from DCS that is returned by USSD.  Copying it directly from the USSD
> DCS seems incorrect.  Or is there something I'm missing?

On irc we figured that the best hint about what is expected to be
returned is in the tests in 31.124.  +CUSD returns sms-like DCS, while
STK expects Cell Broadcast-like DCS and recommends using only the
values 00, 04, 08, so there needs to be a translation from one to the
other (perhaps in stk.c in the ussd callback).  I think you'll also
need a length field in this struct as the data can contain 0s.

Best regards

RE: [PATCH 02/11] Changes done as per the changed driver API

[Jeevaka.Badrappan]

[-- Attachment #1: Type: text/plain, Size: 1632 bytes --]

 
Hi Pekka,

> I thought the modem already unpacks the ussd message to 8-bit gsm and
the dcs parameter is rather meaningless in that case. Perhaps the
atmodem ussd should re-pack the string in order to achieve the 
> desired symmetry on the API?

Agree that the modem already unpacks the string received from the
network to the "character set" set by TE(UCS2 or UTF-8 or ...). Atom
driver will do the conversion to UTF-8 based on active character set
supported by modem, so it should have information of the active
character set. At present, we read and set the "character set" in the
phonebook atom driver. USSD atom driver could to do the same or the
reading/setting of character set can be done during the modem
initialisation (eg: atgen.c). I would prefer to have the reading and
setting of character set during the modem initialisation. I hope the
character set is not set by some other component apart from ofono :-)

Regards,
jeevaka



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.

RE: [PATCH 07/11] added stk_response_text_string for USSD result

[Jeevaka.Badrappan]

[-- Attachment #1: Type: text/plain, Size: 1166 bytes --]

 
Hi,

> On irc we figured that the best hint about what is expected to be
returned is in the tests in 31.124.  +CUSD returns sms-like DCS, while
STK expects Cell Broadcast-like DCS and recommends using only the >
values 00, 04, 08, so there needs to be a translation from one to the
other (perhaps in stk.c in the ussd callback).  I think you'll also need
a length field in this struct as the data can contain 0s.

Will fix the code as per the comments.

Thanks and Regards,
jeevaka


----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.



----------------------------------------------------------------
Please note: This e-mail may contain confidential information
intended solely for the addressee. If you have received this
e-mail in error, please do not disclose it to anyone, notify
the sender promptly, and delete the message from your system.
Thank you.