Register for "+CUSD:" unsolicited responses, also parse +CUSD lines appearing as part of response to AT+CUSD (this form is still used on Nokia phones that emulate AT when connected to a PC, and both forms are allowed by the spec). The latter form is treated differently to make sure the Initiate callback happens before ofono_ussd_notify is called. USSD.Initiate still returns a string, this may be wrong because when the network returns data coded in 8-bits we have no information on the character set used, everything is "user-specified" for the 8-bit coding in the 23.038 and technically we should return an array of bytes. I only handle 7-bit and 8-bit responses, other codings are not specified and I didn't manage to make the network send me anything other than 7-bit coded string, although I managed to send a UCS2-coded USSD string -- the network still only responded with DCS = 15 (but the response content didn't make any sense). The responses from my network were always in the local language but with non-ASCII characters stripped, regardless of the language set in the DCS by me. I removed the "TODO: be able to send UCS2 string" because the string we send is first checked to be a valid USSD string so we already know it can be encoded with GSM 7-bits. --- drivers/atmodem/ussd.c | 110 ++++++++++++++++++++++++++++++++++++++++++------ src/ussd.c | 3 + 2 files changed, 100 insertions(+), 13 deletions(-) diff --git a/drivers/atmodem/ussd.c b/drivers/atmodem/ussd.c index 1d819a3..e35cf72 100644 --- a/drivers/atmodem/ussd.c +++ b/drivers/atmodem/ussd.c @@ -40,39 +40,103 @@ #include "atmodem.h" +struct cusd_req { + ofono_ussd_cb_t cb; + void *data; + struct ofono_ussd *ussd; +}; + +static const char *cusd_prefix[] = { "+CUSD:", NULL }; static const char *none_prefix[] = { NULL }; +static void cusd_parse(GAtResult *result, struct ofono_ussd *ussd) +{ + GAtResultIter iter; + int status; + int dcs; + const guint8 *content; + int length; + char *converted = NULL; + + g_at_result_iter_init(&iter, result); + + if (!g_at_result_iter_next(&iter, "+CUSD:")) + return; + + if (!g_at_result_iter_next_number(&iter, &status)) + return; + + if (!g_at_result_iter_next_hexstring(&iter, &content, &length)) + goto out; + + if (!g_at_result_iter_next_number(&iter, &dcs)) + goto out; + + /* All 7-bit coding schemes - there's no need to distinguish + * between the different schemes because the modem is tasked + * with presenting us with only raw 7-bit characters. + */ + if ((dcs & 0xf0) == 0x00 || dcs == 0x10 || (dcs & 0xf0) == 0x20 || + (dcs & 0xf0) == 0x30 || (dcs & 0xcc) == 0x40 || + (dcs & 0xfc) == 0x90 || (dcs & 0xf4) == 0xf0) + converted = convert_gsm_to_utf8(content, length, + NULL, NULL, 0); + + /* All 8-bit coding schemes - again we can treat all of them + * the same, however we have no information about the character + * set used, for the moment return raw (upper layer will assume + * what we sent it is UTF-8 which may be wrong). + */ + else if ((dcs & 0xcc) == 0x44 || (dcs & 0xfc) == 0x94 || + (dcs & 0xf4) == 0xf4) + converted = g_strndup((char *) content, length); + + /* No other encoding is mentioned in TS27007 7.15 */ + else + ofono_error("Unsupported USSD data coding scheme (%02x)", dcs); + +out: + ofono_ussd_notify(ussd, status, converted); + + if (converted) + g_free(converted); +} + static void cusd_request_cb(gboolean ok, GAtResult *result, gpointer user_data) { - struct cb_data *cbd = user_data; - ofono_ussd_cb_t cb = cbd->cb; + struct cusd_req *cbd = user_data; struct ofono_error error; dump_response("cusd_request_cb", ok, result); decode_at_error(&error, g_at_result_final_response(result)); - cb(&error, cbd->data); + cbd->cb(&error, cbd->data); + + cusd_parse(result, cbd->ussd); } static void at_ussd_request(struct ofono_ussd *ussd, const char *str, ofono_ussd_cb_t cb, void *data) { GAtChat *chat = ofono_ussd_get_data(ussd); - struct cb_data *cbd = cb_data_new(cb, data); + struct cusd_req *cbd = g_try_new0(struct cusd_req, 1); unsigned char *converted = NULL; int dcs; int max_len; + int i; + int len; long written; char buf[256]; if (!cbd) goto error; + cbd->cb = cb; + cbd->data = data; + cbd->ussd = ussd; + converted = convert_utf8_to_gsm(str, strlen(str), NULL, &written, 0); - /* TODO: Be able to convert to UCS2, although the standard does not - * indicate that this is actually possible - */ if (!converted) goto error; else { @@ -83,12 +147,15 @@ static void at_ussd_request(struct ofono_ussd *ussd, const char *str, if (written > max_len) goto error; - sprintf(buf, "AT+CUSD=1,\"%*s\",%d", (int) written, converted, dcs); + len = sprintf(buf, "AT+CUSD=1,\""); + for (i = 0; i < written; i ++) + len += sprintf(buf + len, "%02hhx", converted[i]); + sprintf(buf + len, "\",%d", dcs); g_free(converted); converted = NULL; - if (g_at_chat_send(chat, buf, none_prefix, + if (g_at_chat_send(chat, buf, cusd_prefix, cusd_request_cb, cbd, g_free) > 0) return; @@ -133,13 +200,28 @@ error: CALLBACK_WITH_FAILURE(cb, data); } -static gboolean at_ussd_register(gpointer user) +static void cusd_notify(GAtResult *result, gpointer user_data) +{ + struct ofono_ussd *ussd = user_data; + + dump_response("cssu_notify", TRUE, result); + + cusd_parse(result, ussd); +} + +static void at_ussd_register(gboolean ok, GAtResult *result, gpointer user) { struct ofono_ussd *ussd = user; + GAtChat *chat = ofono_ussd_get_data(ussd); - ofono_ussd_register(ussd); + if (!ok) { + ofono_error("Could not enable CUSD notifications"); + return; + } + + g_at_chat_register(chat, "+CUSD:", cusd_notify, FALSE, ussd, NULL); - return FALSE; + ofono_ussd_register(ussd); } static int at_ussd_probe(struct ofono_ussd *ussd, unsigned int vendor, @@ -148,7 +230,9 @@ static int at_ussd_probe(struct ofono_ussd *ussd, unsigned int vendor, GAtChat *chat = data; ofono_ussd_set_data(ussd, chat); - g_idle_add(at_ussd_register, ussd); + + g_at_chat_send(chat, "AT+CSCS=\"HEX\"", NULL, NULL, NULL, NULL); + g_at_chat_send(chat, "AT+CUSD=1", NULL, at_ussd_register, ussd, NULL); return 0; } diff --git a/src/ussd.c b/src/ussd.c index be50296..2bf378d 100644 --- a/src/ussd.c +++ b/src/ussd.c @@ -313,6 +313,9 @@ void ofono_ussd_notify(struct ofono_ussd *ussd, int status, const char *str) 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, -- 1.6.1