Skip to content

/ ofono

Permalink
71f1240e43

ofono/src/stkutil.c

Go to file
 
 
Cannot retrieve contributors at this time
6535 lines (5357 sloc) 170 KB
Raw Blame
/*
*
* 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 <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <glib.h>
#include <ell/ell.h>
#include <ofono/types.h>
#include "smsutil.h"
#include "stkutil.h"
#include "simutil.h"
#include "util.h"
enum stk_data_object_flag {
DATAOBJ_FLAG_MANDATORY = 1,
DATAOBJ_FLAG_MINIMUM = 2,
DATAOBJ_FLAG_CR = 4,
DATAOBJ_FLAG_LIST = 8,
};
struct stk_file_iter {
const uint8_t *start;
unsigned int pos;
unsigned int max;
uint8_t len;
const uint8_t *file;
};
struct stk_tlv_builder {
struct comprehension_tlv_builder ctlv;
uint8_t *value;
unsigned int len;
unsigned int max_len;
};
typedef bool (*dataobj_handler)(struct comprehension_tlv_iter *, void *);
typedef bool (*dataobj_writer)(struct stk_tlv_builder *, const void *, bool);
/*
* Defined in TS 102.223 Section 8.13
* The type of gsm sms can be SMS-COMMAND AND SMS-SUBMIT. According to 23.040,
* the maximum length is 164 bytes. But for SMS-SUBMIT, sms may be packed by
* ME. Thus the maximum length of messsage could be 160 bytes, instead of 140
* bytes. So the total maximum length could be 184 bytes. Refer TS 31.111,
* section 6.4.10 for details.
*/
struct gsm_sms_tpdu {
unsigned int len;
uint8_t tpdu[184];
};
#define CHECK_TEXT_AND_ICON(text, icon_id) \
if (status != STK_PARSE_RESULT_OK) \
return status; \
\
if ((text == NULL || text[0] == '\0') && icon_id != 0) \
status = STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD; \
static char *decode_text(uint8_t dcs, int len, const unsigned char *data)
{
char *utf8;
enum sms_charset charset;
if (sms_dcs_decode(dcs, NULL, &charset, NULL, NULL) == FALSE)
return NULL;
switch (charset) {
case SMS_CHARSET_7BIT:
{
long written;
unsigned long max_to_unpack = len * 8 / 7;
uint8_t *unpacked = unpack_7bit(data, len, 0, false,
max_to_unpack,
&written, 0);
if (unpacked == NULL)
return NULL;
utf8 = convert_gsm_to_utf8(unpacked, written,
NULL, NULL, 0);
l_free(unpacked);
break;
}
case SMS_CHARSET_8BIT:
utf8 = convert_gsm_to_utf8(data, len, NULL, NULL, 0);
break;
case SMS_CHARSET_UCS2:
utf8 = l_utf8_from_ucs2be(data, len);
break;
default:
utf8 = NULL;
}
return utf8;
}
/* For data object only to indicate its existence */
static bool parse_dataobj_common_bool(struct comprehension_tlv_iter *iter,
bool *out)
{
if (comprehension_tlv_iter_get_length(iter) != 0)
return false;
*out = true;
return true;
}
/* For data object that only has one byte */
static bool parse_dataobj_common_byte(struct comprehension_tlv_iter *iter,
uint8_t *out)
{
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
*out = data[0];
return true;
}
/* For data object that only has text terminated by '\0' */
static bool parse_dataobj_common_text(struct comprehension_tlv_iter *iter,
char **text)
{
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
*text = l_malloc(len + 1);
memcpy(*text, data, len);
(*text)[len] = '\0';
return true;
}
/* For data object that only has a byte array with undetermined length */
static bool parse_dataobj_common_byte_array(struct comprehension_tlv_iter *iter,
struct stk_common_byte_array *array)
{
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
array->len = len;
array->array = l_malloc(len);
memcpy(array->array, data, len);
return true;
}
static void stk_file_iter_init(struct stk_file_iter *iter,
const uint8_t *start, unsigned int len)
{
iter->start = start;
iter->max = len;
iter->pos = 0;
}
static bool stk_file_iter_next(struct stk_file_iter *iter)
{
unsigned int pos = iter->pos;
const unsigned int max = iter->max;
const uint8_t *start = iter->start;
unsigned int i;
uint8_t last_type;
if (pos + 2 >= max)
return false;
/* SIM EFs always start with ROOT MF, 0x3f */
if (start[iter->pos] != 0x3f)
return false;
last_type = 0x3f;
for (i = pos + 2; i < max; i += 2) {
/*
* Check the validity of file type.
* According to TS 11.11, each file id contains of two bytes,
* in which the first byte is the type of file. For GSM is:
* 0x3f: master file
* 0x7f: 1st level dedicated file
* 0x5f: 2nd level dedicated file
* 0x2f: elementary file under the master file
* 0x6f: elementary file under 1st level dedicated file
* 0x4f: elementary file under 2nd level dedicated file
*/
switch (start[i]) {
case 0x2f:
if (last_type != 0x3f)
return false;
break;
case 0x6f:
if (last_type != 0x7f)
return false;
break;
case 0x4f:
if (last_type != 0x5f)
return false;
break;
case 0x7f:
if (last_type != 0x3f)
return false;
break;
case 0x5f:
if (last_type != 0x7f)
return false;
break;
default:
return false;
}
if ((start[i] == 0x2f) || (start[i] == 0x6f) ||
(start[i] == 0x4f)) {
if (i + 1 >= max)
return false;
iter->file = start + pos;
iter->len = i - pos + 2;
iter->pos = i + 2;
return true;
}
last_type = start[i];
}
return false;
}
/* Defined in TS 102.223 Section 8.1 */
static bool parse_dataobj_address(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_address *addr = user;
const uint8_t *data;
unsigned int len;
char *number;
len = comprehension_tlv_iter_get_length(iter);
if (len < 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
number = l_malloc(len * 2 - 1);
addr->ton_npi = data[0];
addr->number = number;
sim_extract_bcd_number(data + 1, len - 1, addr->number);
return true;
}
/* Defined in TS 102.223 Section 8.2 */
static bool parse_dataobj_alpha_id(struct comprehension_tlv_iter *iter,
void *user)
{
char **alpha_id = user;
const uint8_t *data;
unsigned int len;
char *utf8;
len = comprehension_tlv_iter_get_length(iter);
if (len == 0) {
*alpha_id = NULL;
return true;
}
data = comprehension_tlv_iter_get_data(iter);
utf8 = sim_string_to_utf8(data, len);
if (utf8 == NULL)
return false;
*alpha_id = utf8;
return true;
}
/* Defined in TS 102.223 Section 8.3 */
static bool parse_dataobj_subaddress(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_subaddress *subaddr = user;
const uint8_t *data;
unsigned int len;
len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
if (len > sizeof(subaddr->subaddr))
return false;
data = comprehension_tlv_iter_get_data(iter);
subaddr->len = len;
memcpy(subaddr->subaddr, data, len);
subaddr->has_subaddr = true;
return true;
}
/* Defined in TS 102.223 Section 8.4 */
static bool parse_dataobj_ccp(struct comprehension_tlv_iter *iter, void *user)
{
struct stk_ccp *ccp = user;
const uint8_t *data;
unsigned int len;
len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
if (len > sizeof(ccp->ccp))
return false;
data = comprehension_tlv_iter_get_data(iter);
ccp->len = len;
memcpy(ccp->ccp, data, len);
return true;
}
/* Defined in TS 31.111 Section 8.5 */
static bool parse_dataobj_cbs_page(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_cbs_page *cp = user;
const uint8_t *data;
unsigned int len;
len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
if (len > sizeof(cp->page))
return false;
data = comprehension_tlv_iter_get_data(iter);
cp->len = len;
memcpy(cp->page, data, len);
return true;
}
/* Described in TS 102.223 Section 8.8 */
static bool parse_dataobj_duration(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_duration *duration = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
if (data[0] > 0x02)
return false;
if (data[1] == 0)
return false;
duration->unit = data[0];
duration->interval = data[1];
return true;
}
/* Defined in TS 102.223 Section 8.9 */
static bool parse_dataobj_item(struct comprehension_tlv_iter *iter, void *user)
{
struct stk_item *item = user;
const uint8_t *data;
unsigned int len;
char *utf8;
len = comprehension_tlv_iter_get_length(iter);
if (len == 0)
return true;
if (len == 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
/* The identifier is between 0x01 and 0xFF */
if (data[0] == 0)
return false;
utf8 = sim_string_to_utf8(data + 1, len - 1);
if (utf8 == NULL)
return false;
item->id = data[0];
item->text = utf8;
return true;
}
/* Defined in TS 102.223 Section 8.10 */
static bool parse_dataobj_item_id(struct comprehension_tlv_iter *iter,
void *user)
{
uint8_t *id = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
*id = data[0];
return true;
}
/* Defined in TS 102.223 Section 8.11 */
static bool parse_dataobj_response_len(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_response_length *response_len = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
response_len->min = data[0];
response_len->max = data[1];
return true;
}
/* Defined in TS 102.223 Section 8.12 */
static bool parse_dataobj_result(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_result *result = user;
const uint8_t *data;
unsigned int len;
uint8_t *additional;
len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
if ((len < 2) && ((data[0] == 0x20) || (data[0] == 0x21) ||
(data[0] == 0x26) || (data[0] == 0x38) ||
(data[0] == 0x39) || (data[0] == 0x3a) ||
(data[0] == 0x3c) || (data[0] == 0x3d)))
return false;
additional = l_malloc(len - 1);
result->type = data[0];
result->additional_len = len - 1;
result->additional = additional;
memcpy(result->additional, data + 1, len - 1);
return true;
}
/* Defined in TS 102.223 Section 8.13 */
static bool parse_dataobj_gsm_sms_tpdu(struct comprehension_tlv_iter *iter,
void *user)
{
struct gsm_sms_tpdu *tpdu = user;
const uint8_t *data;
unsigned int len;
len = comprehension_tlv_iter_get_length(iter);
if (len < 1 || len > sizeof(tpdu->tpdu))
return false;
data = comprehension_tlv_iter_get_data(iter);
tpdu->len = len;
memcpy(tpdu->tpdu, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.14 */
static bool parse_dataobj_ss(struct comprehension_tlv_iter *iter, void *user)
{
struct stk_ss *ss = user;
const uint8_t *data;
unsigned int len;
char *s;
len = comprehension_tlv_iter_get_length(iter);
if (len < 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
s = l_malloc(len * 2 - 1);
ss->ton_npi = data[0];
ss->ss = s;
sim_extract_bcd_number(data + 1, len - 1, ss->ss);
return true;
}
/* Defined in TS 102.223 Section 8.15 */
static bool parse_dataobj_text(struct comprehension_tlv_iter *iter, void *user)
{
char **text = user;
unsigned int len = comprehension_tlv_iter_get_length(iter);
const uint8_t *data;
char *utf8;
if (len <= 1) {
*text = l_new(char, 1);
return true;
}
data = comprehension_tlv_iter_get_data(iter);
utf8 = decode_text(data[0], len - 1, data + 1);
if (utf8 == NULL)
return false;
*text = utf8;
return true;
}
/* Defined in TS 102.223 Section 8.16 */
static bool parse_dataobj_tone(struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *byte = user;
return parse_dataobj_common_byte(iter, byte);
}
/* Defined in TS 102.223 Section 8.17 */
static bool parse_dataobj_ussd(struct comprehension_tlv_iter *iter, void *user)
{
struct stk_ussd_string *us = user;
unsigned int len = comprehension_tlv_iter_get_length(iter);
const uint8_t *data = comprehension_tlv_iter_get_data(iter);
if (len <= 1 || len > 161)
return false;
us->dcs = data[0];
us->len = len - 1;
memcpy(us->string, data + 1, us->len);
return true;
}
/* Defined in TS 102.223 Section 8.18 */
static bool parse_dataobj_file_list(struct comprehension_tlv_iter *iter,
void *user)
{
struct l_queue **out = user;
struct l_queue *fl;
const uint8_t *data;
unsigned int len;
struct stk_file *sf;
struct stk_file_iter sf_iter;
len = comprehension_tlv_iter_get_length(iter);
if (len < 5)
return false;
data = comprehension_tlv_iter_get_data(iter);
stk_file_iter_init(&sf_iter, data + 1, len - 1);
fl = l_queue_new();
while (stk_file_iter_next(&sf_iter)) {
sf = l_new(struct stk_file, 1);
sf->len = sf_iter.len;
memcpy(sf->file, sf_iter.file, sf_iter.len);
l_queue_push_tail(fl, sf);
}
if (sf_iter.pos != sf_iter.max)
goto error;
*out = fl;
return true;
error:
l_queue_destroy(fl, l_free);
return false;
}
/* Defined in TS 102.223 Section 8.19 */
static bool parse_dataobj_location_info(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_location_info *li = user;
const uint8_t *data;
unsigned int len;
len = comprehension_tlv_iter_get_length(iter);
if ((len != 5) && (len != 7) && (len != 9))
return false;
data = comprehension_tlv_iter_get_data(iter);
sim_parse_mcc_mnc(data, li->mcc, li->mnc);
li->lac_tac = (data[3] << 8) + data[4];
if (len >= 7) {
li->has_ci = true;
li->ci = (data[5] << 8) + data[6];
}
if (len == 9) {
li->has_ext_ci = true;
li->ext_ci = (data[7] << 8) + data[8];
}
return true;
}
/*
* Defined in TS 102.223 Section 8.20.
*
* According to 3GPP TS 24.008, Section 10.5.1.4, IMEI is composed of
* 15 digits and totally 8 bytes are used to represent it.
*
* Bits 1-3 of first byte represent the type of identity, and they
* are 0 1 0 separately for IMEI. Bit 4 of first byte is the odd/even
* indication, and it's 1 to indicate IMEI has odd number of digits (15).
* The rest bytes are coded using BCD coding.
*
* For example, if the IMEI is "123456789012345", then it's coded as
* "1A 32 54 76 98 10 32 54".
*/
static bool parse_dataobj_imei(struct comprehension_tlv_iter *iter,
void *user)
{
char *imei = user;
const uint8_t *data;
unsigned int len;
static const char digit_lut[] = "0123456789*#abc\0";
len = comprehension_tlv_iter_get_length(iter);
if (len != 8)
return false;
data = comprehension_tlv_iter_get_data(iter);
if ((data[0] & 0x0f) != 0x0a)
return false;
/* Assume imei is at least 16 bytes long (15 for imei + null) */
imei[0] = digit_lut[(data[0] & 0xf0) >> 4];
extract_bcd_number(data + 1, 7, imei + 1);
return true;
}
/* Defined in TS 102.223 Section 8.21 */
static bool parse_dataobj_help_request(struct comprehension_tlv_iter *iter,
void *user)
{
bool *ret = user;
return parse_dataobj_common_bool(iter, ret);
}
/* Defined in TS 102.223 Section 8.22 */
static bool parse_dataobj_network_measurement_results(
struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *nmr = user;
const uint8_t *data;
unsigned int len;
len = comprehension_tlv_iter_get_length(iter);
if (len != 0x10)
return false;
data = comprehension_tlv_iter_get_data(iter);
/* Assume network measurement result is 16 bytes long */
memcpy(nmr, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.23 */
static bool parse_dataobj_default_text(struct comprehension_tlv_iter *iter,
void *user)
{
char **text = user;
unsigned int len = comprehension_tlv_iter_get_length(iter);
const uint8_t *data = comprehension_tlv_iter_get_data(iter);
char *utf8;
/* DCS followed by some text, cannot be 1 */
if (len <= 1)
return false;
utf8 = decode_text(data[0], len - 1, data + 1);
if (utf8 == NULL)
return false;
*text = utf8;
return true;
}
/* Defined in TS 102.223 Section 8.24 */
static bool parse_dataobj_items_next_action_indicator(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_items_next_action_indicator *inai = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if ((len < 1) || (len > sizeof(inai->list)))
return false;
data = comprehension_tlv_iter_get_data(iter);
inai->len = len;
memcpy(inai->list, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.25 */
static bool parse_dataobj_event_list(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_event_list *el = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len == 0)
return true;
if (len > sizeof(el->list))
return false;
data = comprehension_tlv_iter_get_data(iter);
el->len = len;
memcpy(el->list, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.26 */
static bool parse_dataobj_cause(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_cause *cause = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if ((len == 1) || (len > sizeof(cause->cause)))
return false;
cause->has_cause = true;
if (len == 0)
return true;
data = comprehension_tlv_iter_get_data(iter);
cause->len = len;
memcpy(cause->cause, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.27 */
static bool parse_dataobj_location_status(struct comprehension_tlv_iter *iter,
void *user)
{
uint8_t *byte = user;
return parse_dataobj_common_byte(iter, byte);
}
/* Defined in TS 102.223 Section 8.28 */
static bool parse_dataobj_transaction_id(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_transaction_id *ti = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if ((len < 1) || (len > sizeof(ti->list)))
return false;
data = comprehension_tlv_iter_get_data(iter);
ti->len = len;
memcpy(ti->list, data, len);
return true;
}
/* Defined in TS 31.111 Section 8.29 */
static bool parse_dataobj_bcch_channel_list(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_bcch_channel_list *bcl = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
unsigned int i;
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
bcl->num = len * 8 / 10;
for (i = 0; i < bcl->num; i++) {
unsigned int index = i * 10 / 8;
unsigned int occupied = i * 10 % 8;
bcl->channels[i] = (data[index] << (2 + occupied)) +
(data[index + 1] >> (6 - occupied));
}
bcl->has_list = true;
return true;
}
/* Defined in TS 102.223 Section 8.30 */
static bool parse_dataobj_call_control_requested_action(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_common_byte_array *array = user;
return parse_dataobj_common_byte_array(iter, array);
}
/* Defined in TS 102.223 Section 8.31 */
static bool parse_dataobj_icon_id(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_icon_id *id = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
id->qualifier = data[0];
id->id = data[1];
return true;
}
/* Defined in TS 102.223 Section 8.32 */
static bool parse_dataobj_item_icon_id_list(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_item_icon_id_list *iiil = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if ((len < 2) || (len > 127))
return false;
data = comprehension_tlv_iter_get_data(iter);
iiil->qualifier = data[0];
iiil->len = len - 1;
memcpy(iiil->list, data + 1, iiil->len);
return true;
}
/* Defined in TS 102.223 Section 8.33 */
static bool parse_dataobj_card_reader_status(
struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *byte = user;
return parse_dataobj_common_byte(iter, byte);
}
/* Defined in TS 102.223 Section 8.34 */
static bool parse_dataobj_card_atr(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_card_atr *ca = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if ((len < 1) || (len > sizeof(ca->atr)))
return false;
data = comprehension_tlv_iter_get_data(iter);
ca->len = len;
memcpy(ca->atr, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.35 */
static bool parse_dataobj_c_apdu(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_c_apdu *ca = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
unsigned int pos;
if ((len < 4) || (len > 241))
return false;
data = comprehension_tlv_iter_get_data(iter);
ca->cla = data[0];
ca->ins = data[1];
ca->p1 = data[2];
ca->p2 = data[3];
pos = 4;
/*
* lc is 0 has the same meaning as lc is absent. But le is 0 means
* the maximum number of bytes expected in the response data field
* is 256. So we need to rely on has_le to know if it presents.
*/
if (len > 5) {
ca->lc = data[4];
if (ca->lc > sizeof(ca->data))
return false;
pos += ca->lc + 1;
if (len - pos > 1)
return false;
memcpy(ca->data, data+5, ca->lc);
}
if (len - pos > 0) {
ca->le = data[len - 1];
ca->has_le = true;
}
return true;
}
/* Defined in TS 102.223 Section 8.36 */
static bool parse_dataobj_r_apdu(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_r_apdu *ra = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if ((len < 2) || (len > 239))
return false;
data = comprehension_tlv_iter_get_data(iter);
ra->sw1 = data[len-2];
ra->sw2 = data[len-1];
if (len > 2) {
ra->len = len - 2;
memcpy(ra->data, data, ra->len);
} else
ra->len = 0;
return true;
}
/* Defined in TS 102.223 Section 8.37 */
static bool parse_dataobj_timer_id(struct comprehension_tlv_iter *iter,
void *user)
{
uint8_t *byte = user;
return parse_dataobj_common_byte(iter, byte);
}
/* Defined in TS 102.223 Section 8.38 */
static bool parse_dataobj_timer_value(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_timer_value *tv = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 3)
return false;
data = comprehension_tlv_iter_get_data(iter);
tv->hour = sms_decode_semi_octet(data[0]);
tv->minute = sms_decode_semi_octet(data[1]);
tv->second = sms_decode_semi_octet(data[2]);
tv->has_value = true;
return true;
}
/* Defined in TS 102.223 Section 8.39 */
static bool parse_dataobj_datetime_timezone(
struct comprehension_tlv_iter *iter, void *user)
{
struct sms_scts *scts = user;
const uint8_t *data;
int offset = 0;
if (comprehension_tlv_iter_get_length(iter) != 7)
return false;
data = comprehension_tlv_iter_get_data(iter);
sms_decode_scts(data, 7, &offset, scts);
return true;
}
/* Defined in TS 102.223 Section 8.40 */
static bool parse_dataobj_at_command(struct comprehension_tlv_iter *iter,
void *user)
{
char **command = user;
return parse_dataobj_common_text(iter, command);
}
/* Defined in TS 102.223 Section 8.41 */
static bool parse_dataobj_at_response(struct comprehension_tlv_iter *iter,
void *user)
{
char **response = user;
return parse_dataobj_common_text(iter, response);
}
/* Defined in TS 102.223 Section 8.42 */
static bool parse_dataobj_bc_repeat_indicator(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_bc_repeat *bc_repeat = user;
if (!parse_dataobj_common_byte(iter, &bc_repeat->value))
return false;
bc_repeat->has_bc_repeat = true;
return true;
}
/* Defined in 102.223 Section 8.43 */
static bool parse_dataobj_imm_resp(struct comprehension_tlv_iter *iter,
void *user)
{
bool *ret = user;
return parse_dataobj_common_bool(iter, ret);
}
/* Defined in 102.223 Section 8.44 */
static bool parse_dataobj_dtmf_string(struct comprehension_tlv_iter *iter,
void *user)
{
char **dtmf = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
*dtmf = l_malloc(len * 2 + 1);
sim_extract_bcd_number(data, len, *dtmf);
return true;
}
/* Defined in 102.223 Section 8.45 */
static bool parse_dataobj_language(struct comprehension_tlv_iter *iter,
void *user)
{
char *lang = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len != 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
/*
* This is a 2 character pair as defined in ISO 639, coded using
* GSM default 7 bit alphabet with bit 8 set to 0. Since the english
* letters have the same mapping in GSM as ASCII, no conversion
* is required here
*/
memcpy(lang, data, len);
lang[len] = '\0';
return true;
}
/* Defined in 31.111 Section 8.46 */
static bool parse_dataobj_timing_advance(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_timing_advance *ta = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len != 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
ta->has_value = true;
ta->status = data[0];
ta->advance = data[1];
return true;
}
/* Defined in 102.223 Section 8.47 */
static bool parse_dataobj_browser_id(struct comprehension_tlv_iter *iter,
void *user)
{
uint8_t *byte = user;
if (!parse_dataobj_common_byte(iter, byte) || *byte > 4)
return false;
return true;
}
/* Defined in TS 102.223 Section 8.48 */
static bool parse_dataobj_url(struct comprehension_tlv_iter *iter, void *user)
{
char **url = user;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len == 0) {
*url = NULL;
return true;
}
return parse_dataobj_common_text(iter, url);
}
/* Defined in TS 102.223 Section 8.49 */
static bool parse_dataobj_bearer(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_common_byte_array *array = user;
return parse_dataobj_common_byte_array(iter, array);
}
/* Defined in TS 102.223 Section 8.50 */
static bool parse_dataobj_provisioning_file_reference(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_file *f = user;
const uint8_t *data;
struct stk_file_iter sf_iter;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if ((len < 1) || (len > 8))
return false;
data = comprehension_tlv_iter_get_data(iter);
stk_file_iter_init(&sf_iter, data, len);
stk_file_iter_next(&sf_iter);
if (sf_iter.pos != sf_iter.max)
return false;
f->len = len;
memcpy(f->file, data, len);
return true;
}
/* Defined in 102.223 Section 8.51 */
static bool parse_dataobj_browser_termination_cause(
struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *byte = user;
return parse_dataobj_common_byte(iter, byte);
}
/* Defined in TS 102.223 Section 8.52 */
static bool parse_dataobj_bearer_description(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_bearer_description *bd = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
bd->type = data[0];
/* Parse only the packet data service bearer parameters */
if (bd->type != STK_BEARER_TYPE_GPRS_UTRAN)
return false;
if (len < 7)
return false;
bd->gprs.precedence = data[1];
bd->gprs.delay = data[2];
bd->gprs.reliability = data[3];
bd->gprs.peak = data[4];
bd->gprs.mean = data[5];
bd->gprs.pdp_type = data[6];
return true;
}
/* Defined in TS 102.223 Section 8.53 */
static bool parse_dataobj_channel_data(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_common_byte_array *array = user;
return parse_dataobj_common_byte_array(iter, array);
}
/* Defined in TS 102.223 Section 8.54 */
static bool parse_dataobj_channel_data_length(
struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *byte = user;
return parse_dataobj_common_byte(iter, byte);
}
/* Defined in TS 102.223 Section 8.55 */
static bool parse_dataobj_buffer_size(struct comprehension_tlv_iter *iter,
void *user)
{
uint16_t *size = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
*size = (data[0] << 8) + data[1];
return true;
}
/* Defined in TS 102.223 Section 8.56 */
static bool parse_dataobj_channel_status(
struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *status = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
/* Assume channel status is 2 bytes long */
memcpy(status, data, 2);
return true;
}
/* Defined in TS 102.223 Section 8.57 */
static bool parse_dataobj_card_reader_id(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_card_reader_id *cr_id = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
cr_id->len = len;
memcpy(cr_id->id, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.58 */
static bool parse_dataobj_other_address(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_other_address *oa = user;
const uint8_t *data;
uint8_t len = comprehension_tlv_iter_get_length(iter);
if (len == 0) {
oa->type = STK_ADDRESS_AUTO;
return true;
}
if ((len != 5) && (len != 17))
return false;
data = comprehension_tlv_iter_get_data(iter);
if (data[0] != STK_ADDRESS_IPV4 && data[0] != STK_ADDRESS_IPV6)
return false;
oa->type = data[0];
if (oa->type == STK_ADDRESS_IPV4)
memcpy(&oa->addr.ipv4, data + 1, 4);
else
memcpy(&oa->addr.ipv6, data + 1, 16);
return true;
}
/* Defined in TS 102.223 Section 8.59 */
static bool parse_dataobj_uicc_te_interface(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_uicc_te_interface *uti = user;
const uint8_t *data;
uint8_t len = comprehension_tlv_iter_get_length(iter);
if (len != 3)
return false;
data = comprehension_tlv_iter_get_data(iter);
uti->protocol = data[0];
uti->port = (data[1] << 8) + data[2];
return true;
}
/* Defined in TS 102.223 Section 8.60 */
static bool parse_dataobj_aid(struct comprehension_tlv_iter *iter, void *user)
{
struct stk_aid *aid = user;
const uint8_t *data;
uint8_t len = comprehension_tlv_iter_get_length(iter);
if ((len > 16) || (len < 12))
return false;
data = comprehension_tlv_iter_get_data(iter);
aid->len = len;
memcpy(aid->aid, data, len);
return true;
}
/*
* Defined in TS 102.223 Section 8.61. According to it, the technology field
* can have at most 127 bytes. However, all the defined values are only 1 byte,
* so we just use 1 byte to represent it.
*/
static bool parse_dataobj_access_technology(
struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *byte = user;
return parse_dataobj_common_byte(iter, byte);
}
/* Defined in TS 102.223 Section 8.62 */
static bool parse_dataobj_display_parameters(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_display_parameters *dp = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 3)
return false;
data = comprehension_tlv_iter_get_data(iter);
dp->height = data[0];
dp->width = data[1];
dp->effects = data[2];
return true;
}
/* Defined in TS 102.223 Section 8.63 */
static bool parse_dataobj_service_record(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_service_record *sr = user;
const uint8_t *data;
unsigned int len;
len = comprehension_tlv_iter_get_length(iter);
if (len < 3)
return false;
data = comprehension_tlv_iter_get_data(iter);
sr->tech_id = data[0];
sr->serv_id = data[1];
sr->len = len - 2;
sr->serv_rec = l_malloc(sr->len);
memcpy(sr->serv_rec, data + 2, sr->len);
return true;
}
/* Defined in TS 102.223 Section 8.64 */
static bool parse_dataobj_device_filter(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_device_filter *df = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
/* According to TS 102.223, everything except BT & IRDA is RFU */
if (data[0] != STK_TECHNOLOGY_BLUETOOTH &&
data[0] != STK_TECHNOLOGY_IRDA)
return false;
df->tech_id = data[0];
df->len = len - 1;
df->dev_filter = l_malloc(df->len);
memcpy(df->dev_filter, data + 1, df->len);
return true;
}
/* Defined in TS 102.223 Section 8.65 */
static bool parse_dataobj_service_search(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_service_search *ss = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
/* According to TS 102.223, everything except BT & IRDA is RFU */
if (data[0] != STK_TECHNOLOGY_BLUETOOTH &&
data[0] != STK_TECHNOLOGY_IRDA)
return false;
ss->tech_id = data[0];
ss->len = len - 1;
ss->ser_search = l_malloc(ss->len);
memcpy(ss->ser_search, data + 1, ss->len);
return true;
}
/* Defined in TS 102.223 Section 8.66 */
static bool parse_dataobj_attribute_info(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_attribute_info *ai = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
/* According to TS 102.223, everything except BT & IRDA is RFU */
if (data[0] != STK_TECHNOLOGY_BLUETOOTH &&
data[0] != STK_TECHNOLOGY_IRDA)
return false;
ai->tech_id = data[0];
ai->len = len - 1;
ai->attr_info = l_malloc(ai->len);
memcpy(ai->attr_info, data + 1, ai->len);
return true;
}
/* Defined in TS 102.223 Section 8.67 */
static bool parse_dataobj_service_availability(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_common_byte_array *array = user;
return parse_dataobj_common_byte_array(iter, array);
}
/* Defined in TS 102.223 Section 8.68 */
static bool parse_dataobj_remote_entity_address(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_remote_entity_address *rea = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
data = comprehension_tlv_iter_get_data(iter);
switch (data[0]) {
case 0x00:
if (len != 7)
return false;
break;
case 0x01:
if (len != 5)
return false;
break;
default:
return false;
}
rea->has_address = true;
rea->coding_type = data[0];
memcpy(&rea->addr, data + 1, len - 1);
return true;
}
/* Defined in TS 102.223 Section 8.69 */
static bool parse_dataobj_esn(struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *esn = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len != 4)
return false;
data = comprehension_tlv_iter_get_data(iter);
/* Assume esn is 4 bytes long */
memcpy(esn, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.70 */
static bool parse_dataobj_network_access_name(
struct comprehension_tlv_iter *iter,
void *user)
{
char **apn = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
uint8_t label_size;
uint8_t offset = 0;
char decoded_apn[100];
if (len == 0 || len > 100)
return false;
data = comprehension_tlv_iter_get_data(iter);
/*
* As specified in TS 23 003 Section 9
* The APN consists of one or more labels. Each label is coded as
* a one octet length field followed by that number of octets coded
* as 8 bit ASCII characters
*/
while (len) {
label_size = *data;
if (label_size == 0 || label_size > (len - 1))
return false;
memcpy(decoded_apn + offset, data + 1, label_size);
data += label_size + 1;
offset += label_size;
len -= label_size + 1;
if (len)
decoded_apn[offset++] = '.';
}
decoded_apn[offset] = '\0';
*apn = l_strdup(decoded_apn);
return true;
}
/* Defined in TS 102.223 Section 8.71 */
static bool parse_dataobj_cdma_sms_tpdu(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_common_byte_array *array = user;
return parse_dataobj_common_byte_array(iter, array);
}
/* Defined in TS 102.223 Section 8.72 */
static bool parse_dataobj_text_attr(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_text_attribute *attr = user;
const uint8_t *data;
unsigned int len;
len = comprehension_tlv_iter_get_length(iter);
if (len > sizeof(attr->attributes))
return false;
data = comprehension_tlv_iter_get_data(iter);
memcpy(attr->attributes, data, len);
attr->len = len;
return true;
}
/* Defined in TS 31.111 Section 8.72 */
static bool parse_dataobj_pdp_act_par(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_pdp_act_par *pcap = user;
const uint8_t *data;
unsigned int len;
len = comprehension_tlv_iter_get_length(iter);
if (len > sizeof(pcap->par))
return false;
data = comprehension_tlv_iter_get_data(iter);
memcpy(pcap->par, data, len);
pcap->len = len;
return true;
}
/* Defined in TS 102.223 Section 8.73 */
static bool parse_dataobj_item_text_attribute_list(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_item_text_attribute_list *ital = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if ((len > sizeof(ital->list)) || (len % 4 != 0))
return false;
data = comprehension_tlv_iter_get_data(iter);
memcpy(ital->list, data, len);
ital->len = len;
return true;
}
/* Defined in TS 31.111 Section 8.73 */
static bool parse_dataobj_utran_meas_qualifier(
struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *byte = user;
return parse_dataobj_common_byte(iter, byte);
}
/*
* Defined in TS 102.223 Section 8.74.
*
* According to 3GPP TS 24.008, Section 10.5.1.4, IMEISV is composed of
* 16 digits and totally 9 bytes are used to represent it.
*
* Bits 1-3 of first byte represent the type of identity, and they
* are 0 1 1 separately for IMEISV. Bit 4 of first byte is the odd/even
* indication, and it's 0 to indicate IMEISV has odd number of digits (16).
* The rest bytes are coded using BCD coding.
*
* For example, if the IMEISV is "1234567890123456", then it's coded as
* "13 32 54 76 98 10 32 54 F6".
*/
static bool parse_dataobj_imeisv(struct comprehension_tlv_iter *iter,
void *user)
{
char *imeisv = user;
const uint8_t *data;
unsigned int len;
static const char digit_lut[] = "0123456789*#abc\0";
len = comprehension_tlv_iter_get_length(iter);
if (len != 9)
return false;
data = comprehension_tlv_iter_get_data(iter);
if ((data[0] & 0x0f) != 0x03)
return false;
if (data[8] >> 4 != 0x0f)
return false;
/* Assume imeisv is at least 17 bytes long (16 for imeisv + null) */
imeisv[0] = digit_lut[data[0] >> 4];
extract_bcd_number(data + 1, 7, imeisv + 1);
imeisv[15] = digit_lut[data[8] & 0x0f];
imeisv[16] = '\0';
return true;
}
/* Defined in TS 102.223 Section 8.75 */
static bool parse_dataobj_network_search_mode(
struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *byte = user;
return parse_dataobj_common_byte(iter, byte);
}
/* Defined in TS 102.223 Section 8.76 */
static bool parse_dataobj_battery_state(struct comprehension_tlv_iter *iter,
void *user)
{
uint8_t *byte = user;
return parse_dataobj_common_byte(iter, byte);
}
/* Defined in TS 102.223 Section 8.77 */
static bool parse_dataobj_browsing_status(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_common_byte_array *array = user;
return parse_dataobj_common_byte_array(iter, array);
}
/* Defined in TS 102.223 Section 8.78 */
static bool parse_dataobj_frame_layout(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_frame_layout *fl = user;
const uint8_t *data;
uint8_t len = comprehension_tlv_iter_get_length(iter);
if (len < 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
if (data[0] != STK_LAYOUT_HORIZONTAL &&
data[0] != STK_LAYOUT_VERTICAL)
return false;
fl->layout = data[0];
fl->len = len - 1;
memcpy(fl->size, data + 1, fl->len);
return true;
}
/* Defined in TS 102.223 Section 8.79 */
static bool parse_dataobj_frames_info(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_frames_info *fi = user;
const uint8_t *data;
uint8_t len = comprehension_tlv_iter_get_length(iter);
unsigned int i;
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
if (data[0] > 0x0f)
return false;
if ((len == 1 && data[0] != 0) || (len > 1 && data[0] == 0))
return false;
if (len % 2 == 0)
return false;
if (len == 1)
return true;
fi->id = data[0];
fi->len = (len - 1) / 2;
for (i = 0; i < len; i++) {
fi->list[i].height = data[i * 2 + 1] & 0x1f;
fi->list[i].width = data[i * 2 + 2] & 0x7f;
}
return true;
}
/* Defined in TS 102.223 Section 8.80 */
static bool parse_dataobj_frame_id(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_frame_id *fi = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
if (data[0] >= 0x10)
return false;
fi->has_id = true;
fi->id = data[0];
return true;
}
/* Defined in TS 102.223 Section 8.81 */
static bool parse_dataobj_meid(struct comprehension_tlv_iter *iter,
void *user)
{
uint8_t *meid = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 8)
return false;
data = comprehension_tlv_iter_get_data(iter);
/* Assume meid is 8 bytes long */
memcpy(meid, data, 8);
return true;
}
/* Defined in TS 102.223 Section 8.82 */
static bool parse_dataobj_mms_reference(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_mms_reference *mr = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
mr->len = len;
memcpy(mr->ref, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.83 */
static bool parse_dataobj_mms_id(struct comprehension_tlv_iter *iter,
void *user)
{
struct stk_mms_id *mi = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
mi->len = len;
memcpy(mi->id, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.84 */
static bool parse_dataobj_mms_transfer_status(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_mms_transfer_status *mts = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
mts->len = len;
memcpy(mts->status, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.85 */
static bool parse_dataobj_mms_content_id(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_mms_content_id *mci = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
mci->len = len;
memcpy(mci->id, data, len);
return true;
}
/* Defined in TS 102.223 Section 8.86 */
static bool parse_dataobj_mms_notification(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_common_byte_array *array = user;
return parse_dataobj_common_byte_array(iter, array);
}
/* Defined in TS 102.223 Section 8.87 */
static bool parse_dataobj_last_envelope(struct comprehension_tlv_iter *iter,
void *user)
{
bool *ret = user;
return parse_dataobj_common_bool(iter, ret);
}
/* Defined in TS 102.223 Section 8.88 */
static bool parse_dataobj_registry_application_data(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_registry_application_data *rad = user;
const uint8_t *data;
char *utf8;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 5)
return false;
data = comprehension_tlv_iter_get_data(iter);
utf8 = decode_text(data[2], len - 4, data + 4);
if (utf8 == NULL)
return false;
rad->name = utf8;
rad->port = (data[0] << 8) + data[1];
rad->type = data[3];
return true;
}
/* Defined in TS 102.223 Section 8.89 */
static bool parse_dataobj_activate_descriptor(
struct comprehension_tlv_iter *iter, void *user)
{
uint8_t *byte = user;
const uint8_t *data;
if (comprehension_tlv_iter_get_length(iter) != 1)
return false;
data = comprehension_tlv_iter_get_data(iter);
if (data[0] != 0x01)
return false;
*byte = data[0];
return true;
}
/* Defined in TS 102.223 Section 8.90 */
static bool parse_dataobj_broadcast_network_info(
struct comprehension_tlv_iter *iter, void *user)
{
struct stk_broadcast_network_information *bni = user;
const uint8_t *data;
unsigned int len = comprehension_tlv_iter_get_length(iter);
if (len < 2)
return false;
data = comprehension_tlv_iter_get_data(iter);
if (data[0] > 0x03)
return false;
bni->tech = data[0];
bni->len = len - 1;
memcpy(bni->loc_info, data + 1, bni->len);
return true;
}
static dataobj_handler handler_for_type(enum stk_data_object_type type)
{
switch (type) {
case STK_DATA_OBJECT_TYPE_ADDRESS:
return parse_dataobj_address;
case STK_DATA_OBJECT_TYPE_ALPHA_ID:
return parse_dataobj_alpha_id;
case STK_DATA_OBJECT_TYPE_SUBADDRESS:
return parse_dataobj_subaddress;
case STK_DATA_OBJECT_TYPE_CCP:
return parse_dataobj_ccp;
case STK_DATA_OBJECT_TYPE_CBS_PAGE:
return parse_dataobj_cbs_page;
case STK_DATA_OBJECT_TYPE_DURATION:
return parse_dataobj_duration;
case STK_DATA_OBJECT_TYPE_ITEM:
return parse_dataobj_item;
case STK_DATA_OBJECT_TYPE_ITEM_ID:
return parse_dataobj_item_id;
case STK_DATA_OBJECT_TYPE_RESPONSE_LENGTH:
return parse_dataobj_response_len;
case STK_DATA_OBJECT_TYPE_RESULT:
return parse_dataobj_result;
case STK_DATA_OBJECT_TYPE_GSM_SMS_TPDU:
return parse_dataobj_gsm_sms_tpdu;
case STK_DATA_OBJECT_TYPE_SS_STRING:
return parse_dataobj_ss;
case STK_DATA_OBJECT_TYPE_TEXT:
return parse_dataobj_text;
case STK_DATA_OBJECT_TYPE_TONE:
return parse_dataobj_tone;
case STK_DATA_OBJECT_TYPE_USSD_STRING:
return parse_dataobj_ussd;
case STK_DATA_OBJECT_TYPE_FILE_LIST:
return parse_dataobj_file_list;
case STK_DATA_OBJECT_TYPE_LOCATION_INFO:
return parse_dataobj_location_info;
case STK_DATA_OBJECT_TYPE_IMEI:
return parse_dataobj_imei;
case STK_DATA_OBJECT_TYPE_HELP_REQUEST:
return parse_dataobj_help_request;
case STK_DATA_OBJECT_TYPE_NETWORK_MEASUREMENT_RESULTS:
return parse_dataobj_network_measurement_results;
case STK_DATA_OBJECT_TYPE_DEFAULT_TEXT:
return parse_dataobj_default_text;
case STK_DATA_OBJECT_TYPE_ITEMS_NEXT_ACTION_INDICATOR:
return parse_dataobj_items_next_action_indicator;
case STK_DATA_OBJECT_TYPE_EVENT_LIST:
return parse_dataobj_event_list;
case STK_DATA_OBJECT_TYPE_CAUSE:
return parse_dataobj_cause;
case STK_DATA_OBJECT_TYPE_LOCATION_STATUS:
return parse_dataobj_location_status;
case STK_DATA_OBJECT_TYPE_TRANSACTION_ID:
return parse_dataobj_transaction_id;
case STK_DATA_OBJECT_TYPE_BCCH_CHANNEL_LIST:
return parse_dataobj_bcch_channel_list;
case STK_DATA_OBJECT_TYPE_CALL_CONTROL_REQUESTED_ACTION:
return parse_dataobj_call_control_requested_action;
case STK_DATA_OBJECT_TYPE_ICON_ID:
return parse_dataobj_icon_id;
case STK_DATA_OBJECT_TYPE_ITEM_ICON_ID_LIST:
return parse_dataobj_item_icon_id_list;
case STK_DATA_OBJECT_TYPE_CARD_READER_STATUS:
return parse_dataobj_card_reader_status;
case STK_DATA_OBJECT_TYPE_CARD_ATR:
return parse_dataobj_card_atr;
case STK_DATA_OBJECT_TYPE_C_APDU:
return parse_dataobj_c_apdu;
case STK_DATA_OBJECT_TYPE_R_APDU:
return parse_dataobj_r_apdu;
case STK_DATA_OBJECT_TYPE_TIMER_ID:
return parse_dataobj_timer_id;
case STK_DATA_OBJECT_TYPE_TIMER_VALUE:
return parse_dataobj_timer_value;
case STK_DATA_OBJECT_TYPE_DATETIME_TIMEZONE:
return parse_dataobj_datetime_timezone;
case STK_DATA_OBJECT_TYPE_AT_COMMAND:
return parse_dataobj_at_command;
case STK_DATA_OBJECT_TYPE_AT_RESPONSE:
return parse_dataobj_at_response;
case STK_DATA_OBJECT_TYPE_BC_REPEAT_INDICATOR:
return parse_dataobj_bc_repeat_indicator;
case STK_DATA_OBJECT_TYPE_IMMEDIATE_RESPONSE:
return parse_dataobj_imm_resp;
case STK_DATA_OBJECT_TYPE_DTMF_STRING:
return parse_dataobj_dtmf_string;
case STK_DATA_OBJECT_TYPE_LANGUAGE:
return parse_dataobj_language;
case STK_DATA_OBJECT_TYPE_BROWSER_ID:
return parse_dataobj_browser_id;
case STK_DATA_OBJECT_TYPE_TIMING_ADVANCE:
return parse_dataobj_timing_advance;
case STK_DATA_OBJECT_TYPE_URL:
return parse_dataobj_url;
case STK_DATA_OBJECT_TYPE_BEARER:
return parse_dataobj_bearer;
case STK_DATA_OBJECT_TYPE_PROVISIONING_FILE_REF:
return parse_dataobj_provisioning_file_reference;
case STK_DATA_OBJECT_TYPE_BROWSER_TERMINATION_CAUSE:
return parse_dataobj_browser_termination_cause;
case STK_DATA_OBJECT_TYPE_BEARER_DESCRIPTION:
return parse_dataobj_bearer_description;
case STK_DATA_OBJECT_TYPE_CHANNEL_DATA:
return parse_dataobj_channel_data;
case STK_DATA_OBJECT_TYPE_CHANNEL_DATA_LENGTH:
return parse_dataobj_channel_data_length;
case STK_DATA_OBJECT_TYPE_BUFFER_SIZE:
return parse_dataobj_buffer_size;
case STK_DATA_OBJECT_TYPE_CHANNEL_STATUS:
return parse_dataobj_channel_status;
case STK_DATA_OBJECT_TYPE_CARD_READER_ID:
return parse_dataobj_card_reader_id;
case STK_DATA_OBJECT_TYPE_OTHER_ADDRESS:
return parse_dataobj_other_address;
case STK_DATA_OBJECT_TYPE_UICC_TE_INTERFACE:
return parse_dataobj_uicc_te_interface;
case STK_DATA_OBJECT_TYPE_AID:
return parse_dataobj_aid;
case STK_DATA_OBJECT_TYPE_ACCESS_TECHNOLOGY:
return parse_dataobj_access_technology;
case STK_DATA_OBJECT_TYPE_DISPLAY_PARAMETERS:
return parse_dataobj_display_parameters;
case STK_DATA_OBJECT_TYPE_SERVICE_RECORD:
return parse_dataobj_service_record;
case STK_DATA_OBJECT_TYPE_DEVICE_FILTER:
return parse_dataobj_device_filter;
case STK_DATA_OBJECT_TYPE_SERVICE_SEARCH:
return parse_dataobj_service_search;
case STK_DATA_OBJECT_TYPE_ATTRIBUTE_INFO:
return parse_dataobj_attribute_info;
case STK_DATA_OBJECT_TYPE_SERVICE_AVAILABILITY:
return parse_dataobj_service_availability;
case STK_DATA_OBJECT_TYPE_REMOTE_ENTITY_ADDRESS:
return parse_dataobj_remote_entity_address;
case STK_DATA_OBJECT_TYPE_ESN:
return parse_dataobj_esn;
case STK_DATA_OBJECT_TYPE_NETWORK_ACCESS_NAME:
return parse_dataobj_network_access_name;
case STK_DATA_OBJECT_TYPE_CDMA_SMS_TPDU:
return parse_dataobj_cdma_sms_tpdu;
case STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE:
return parse_dataobj_text_attr;
case STK_DATA_OBJECT_TYPE_PDP_ACTIVATION_PARAMETER:
return parse_dataobj_pdp_act_par;
case STK_DATA_OBJECT_TYPE_ITEM_TEXT_ATTRIBUTE_LIST:
return parse_dataobj_item_text_attribute_list;
case STK_DATA_OBJECT_TYPE_UTRAN_MEASUREMENT_QUALIFIER:
return parse_dataobj_utran_meas_qualifier;
case STK_DATA_OBJECT_TYPE_IMEISV:
return parse_dataobj_imeisv;
case STK_DATA_OBJECT_TYPE_NETWORK_SEARCH_MODE:
return parse_dataobj_network_search_mode;
case STK_DATA_OBJECT_TYPE_BATTERY_STATE:
return parse_dataobj_battery_state;
case STK_DATA_OBJECT_TYPE_BROWSING_STATUS:
return parse_dataobj_browsing_status;
case STK_DATA_OBJECT_TYPE_FRAME_LAYOUT:
return parse_dataobj_frame_layout;
case STK_DATA_OBJECT_TYPE_FRAMES_INFO:
return parse_dataobj_frames_info;
case STK_DATA_OBJECT_TYPE_FRAME_ID:
return parse_dataobj_frame_id;
case STK_DATA_OBJECT_TYPE_MEID:
return parse_dataobj_meid;
case STK_DATA_OBJECT_TYPE_MMS_REFERENCE:
return parse_dataobj_mms_reference;
case STK_DATA_OBJECT_TYPE_MMS_ID:
return parse_dataobj_mms_id;
case STK_DATA_OBJECT_TYPE_MMS_TRANSFER_STATUS:
return parse_dataobj_mms_transfer_status;
case STK_DATA_OBJECT_TYPE_MMS_CONTENT_ID:
return parse_dataobj_mms_content_id;
case STK_DATA_OBJECT_TYPE_MMS_NOTIFICATION:
return parse_dataobj_mms_notification;
case STK_DATA_OBJECT_TYPE_LAST_ENVELOPE:
return parse_dataobj_last_envelope;
case STK_DATA_OBJECT_TYPE_REGISTRY_APPLICATION_DATA:
return parse_dataobj_registry_application_data;
case STK_DATA_OBJECT_TYPE_ACTIVATE_DESCRIPTOR:
return parse_dataobj_activate_descriptor;
case STK_DATA_OBJECT_TYPE_BROADCAST_NETWORK_INFO:
return parse_dataobj_broadcast_network_info;
default:
return NULL;
}
}
static void destroy_stk_item(gpointer pointer)
{
struct stk_item *item = pointer;
l_free(item->text);
l_free(item);
}
static bool parse_item_list(struct comprehension_tlv_iter *iter, void *data)
{
struct l_queue **out = data;
uint16_t tag = STK_DATA_OBJECT_TYPE_ITEM;
struct comprehension_tlv_iter iter_old;
struct stk_item item;
struct l_queue *list = l_queue_new();
unsigned int count = 0;
bool has_empty = false;
do {
comprehension_tlv_iter_copy(iter, &iter_old);
memset(&item, 0, sizeof(item));
count++;
if (!parse_dataobj_item(iter, &item))
continue;
if (item.id == 0) {
has_empty = true;
continue;
}
l_queue_push_tail(list, l_memdup(&item, sizeof(item)));
} while (comprehension_tlv_iter_next(iter) == TRUE &&
comprehension_tlv_iter_get_tag(iter) == tag);
comprehension_tlv_iter_copy(&iter_old, iter);
if (!has_empty || count == 1) {
*out = list;
return true;
}
l_queue_destroy(list, destroy_stk_item);
return false;
}
static bool parse_provisioning_list(struct comprehension_tlv_iter *iter,
void *data)
{
struct l_queue **out = data;
uint16_t tag = STK_DATA_OBJECT_TYPE_PROVISIONING_FILE_REF;
struct comprehension_tlv_iter iter_old;
struct stk_file file;
struct l_queue *list = l_queue_new();
do {
comprehension_tlv_iter_copy(iter, &iter_old);
memset(&file, 0, sizeof(file));
if (!parse_dataobj_provisioning_file_reference(iter, &file))
continue;
l_queue_push_tail(list, l_memdup(&file, sizeof(file)));
} while (comprehension_tlv_iter_next(iter) == TRUE &&
comprehension_tlv_iter_get_tag(iter) == tag);
comprehension_tlv_iter_copy(&iter_old, iter);
*out = list;
return true;
}
static dataobj_handler list_handler_for_type(enum stk_data_object_type type)
{
switch (type) {
case STK_DATA_OBJECT_TYPE_ITEM:
return parse_item_list;
case STK_DATA_OBJECT_TYPE_PROVISIONING_FILE_REF:
return parse_provisioning_list;
default:
return NULL;
}
}
struct dataobj_handler_entry {
enum stk_data_object_type type;
int flags;
void *data;
};
static enum stk_command_parse_result parse_dataobj(
struct comprehension_tlv_iter *iter,
enum stk_data_object_type type, ...)
{
GSList *entries = NULL;
GSList *l;
va_list args;
bool minimum_set = true;
bool parse_error = false;
va_start(args, type);
while (type != STK_DATA_OBJECT_TYPE_INVALID) {
struct dataobj_handler_entry *entry;
entry = g_new0(struct dataobj_handler_entry, 1);
entry->type = type;
entry->flags = va_arg(args, int);
entry->data = va_arg(args, void *);
type = va_arg(args, enum stk_data_object_type);
entries = g_slist_prepend(entries, entry);
}
va_end(args);
entries = g_slist_reverse(entries);
l = entries;
while (comprehension_tlv_iter_next(iter) == TRUE) {
dataobj_handler handler;
struct dataobj_handler_entry *entry;
GSList *l2;
for (l2 = l; l2; l2 = l2->next) {
entry = l2->data;
if (comprehension_tlv_iter_get_tag(iter) == entry->type)
break;
/* Can't skip over mandatory objects */
if (entry->flags & DATAOBJ_FLAG_MANDATORY) {
l2 = NULL;
break;
}
}
if (l2 == NULL) {
if (comprehension_tlv_get_cr(iter) == TRUE)
parse_error = true;
continue;
}
if (entry->flags & DATAOBJ_FLAG_LIST)
handler = list_handler_for_type(entry->type);
else
handler = handler_for_type(entry->type);
if (!handler(iter, entry->data))
parse_error = true;
l = l2->next;
}
for (; l; l = l->next) {
struct dataobj_handler_entry *entry = l->data;
if (entry->flags & DATAOBJ_FLAG_MANDATORY)
minimum_set = false;
}
g_slist_free_full(entries, g_free);
if (!minimum_set)
return STK_PARSE_RESULT_MISSING_VALUE;
if (parse_error)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return STK_PARSE_RESULT_OK;
}
static void destroy_display_text(struct stk_command *command)
{
l_free(command->display_text.text);
}
static enum stk_command_parse_result parse_display_text(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_display_text *obj = &command->display_text;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_DISPLAY)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_display_text;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_TEXT,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->text,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_IMMEDIATE_RESPONSE, 0,
&obj->immediate_response,
STK_DATA_OBJECT_TYPE_DURATION, 0,
&obj->duration,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->text, obj->icon_id.id);
return status;
}
static void destroy_get_inkey(struct stk_command *command)
{
l_free(command->get_inkey.text);
}
static enum stk_command_parse_result parse_get_inkey(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_get_inkey *obj = &command->get_inkey;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_get_inkey;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_TEXT,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->text,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_DURATION, 0,
&obj->duration,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->text, obj->icon_id.id);
return status;
}
static void destroy_get_input(struct stk_command *command)
{
l_free(command->get_input.text);
l_free(command->get_input.default_text);
}
static enum stk_command_parse_result parse_get_input(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_get_input *obj = &command->get_input;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_get_input;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_TEXT,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->text,
STK_DATA_OBJECT_TYPE_RESPONSE_LENGTH,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->resp_len,
STK_DATA_OBJECT_TYPE_DEFAULT_TEXT, 0,
&obj->default_text,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->text, obj->icon_id.id);
return status;
}
static enum stk_command_parse_result parse_more_time(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return STK_PARSE_RESULT_OK;
}
static void destroy_play_tone(struct stk_command *command)
{
l_free(command->play_tone.alpha_id);
}
static enum stk_command_parse_result parse_play_tone(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_play_tone *obj = &command->play_tone;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_EARPIECE)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_play_tone;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_TONE, 0,
&obj->tone,
STK_DATA_OBJECT_TYPE_DURATION, 0,
&obj->duration,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static enum stk_command_parse_result parse_poll_interval(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_poll_interval *obj = &command->poll_interval;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_DURATION,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->duration,
STK_DATA_OBJECT_TYPE_INVALID);
}
static void destroy_setup_menu(struct stk_command *command)
{
l_free(command->setup_menu.alpha_id);
l_queue_destroy(command->setup_menu.items, destroy_stk_item);
}
static enum stk_command_parse_result parse_setup_menu(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_setup_menu *obj = &command->setup_menu;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_setup_menu;
status = parse_dataobj(iter,
STK_DATA_OBJECT_TYPE_ALPHA_ID,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ITEM,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM |
DATAOBJ_FLAG_LIST, &obj->items,
STK_DATA_OBJECT_TYPE_ITEMS_NEXT_ACTION_INDICATOR, 0,
&obj->next_act,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_ITEM_ICON_ID_LIST, 0,
&obj->item_icon_id_list,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_ITEM_TEXT_ATTRIBUTE_LIST, 0,
&obj->item_text_attr_list,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static void destroy_select_item(struct stk_command *command)
{
l_free(command->select_item.alpha_id);
l_queue_destroy(command->select_item.items, destroy_stk_item);
}
static enum stk_command_parse_result parse_select_item(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_select_item *obj = &command->select_item;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
status = parse_dataobj(iter,
STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ITEM,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM |
DATAOBJ_FLAG_LIST, &obj->items,
STK_DATA_OBJECT_TYPE_ITEMS_NEXT_ACTION_INDICATOR, 0,
&obj->next_act,
STK_DATA_OBJECT_TYPE_ITEM_ID, 0,
&obj->item_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_ITEM_ICON_ID_LIST, 0,
&obj->item_icon_id_list,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_ITEM_TEXT_ATTRIBUTE_LIST, 0,
&obj->item_text_attr_list,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
command->destructor = destroy_select_item;
if (status == STK_PARSE_RESULT_OK && l_queue_isempty(obj->items))
status = STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static void destroy_send_sms(struct stk_command *command)
{
l_free(command->send_sms.alpha_id);
l_free(command->send_sms.cdma_sms.array);
}
static enum stk_command_parse_result parse_send_sms(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_send_sms *obj = &command->send_sms;
enum stk_command_parse_result status;
struct gsm_sms_tpdu gsm_tpdu;
struct stk_address sc_address = { 0, NULL };
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_NETWORK)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
memset(&gsm_tpdu, 0, sizeof(gsm_tpdu));
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ADDRESS, 0,
&sc_address,
STK_DATA_OBJECT_TYPE_GSM_SMS_TPDU, 0,
&gsm_tpdu,
STK_DATA_OBJECT_TYPE_CDMA_SMS_TPDU, 0,
&obj->cdma_sms,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
command->destructor = destroy_send_sms;
if (status != STK_PARSE_RESULT_OK)
goto out;
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
if (status != STK_PARSE_RESULT_OK)
goto out;
if (gsm_tpdu.len == 0 && obj->cdma_sms.len == 0) {
status = STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
goto out;
}
if (gsm_tpdu.len > 0 && obj->cdma_sms.len > 0) {
status = STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
goto out;
}
/* We don't process CDMA pdus for now */
if (obj->cdma_sms.len > 0)
goto out;
/* packing is needed */
if (command->qualifier & 0x01) {
if (!sms_decode_unpacked_stk_pdu(gsm_tpdu.tpdu, gsm_tpdu.len,
&obj->gsm_sms)) {
status = STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
goto out;
}
goto set_addr;
}
if (sms_decode(gsm_tpdu.tpdu, gsm_tpdu.len, TRUE,
gsm_tpdu.len, &obj->gsm_sms) == FALSE) {
status = STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
goto out;
}
if (obj->gsm_sms.type != SMS_TYPE_SUBMIT &&
obj->gsm_sms.type != SMS_TYPE_COMMAND) {
status = STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
goto out;
}
set_addr:
if (sc_address.number == NULL)
goto out;
if (strlen(sc_address.number) > 20) {
status = STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
goto out;
}
strcpy(obj->gsm_sms.sc_addr.address, sc_address.number);
obj->gsm_sms.sc_addr.numbering_plan = sc_address.ton_npi & 15;
obj->gsm_sms.sc_addr.number_type = (sc_address.ton_npi >> 4) & 7;
out:
l_free(sc_address.number);
return status;
}
static void destroy_send_ss(struct stk_command *command)
{
l_free(command->send_ss.alpha_id);
l_free(command->send_ss.ss.ss);
}
static enum stk_command_parse_result parse_send_ss(struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_send_ss *obj = &command->send_ss;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_NETWORK)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_send_ss;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_SS_STRING,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->ss,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
}
static void destroy_send_ussd(struct stk_command *command)
{
l_free(command->send_ussd.alpha_id);
}
static enum stk_command_parse_result parse_send_ussd(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_send_ussd *obj = &command->send_ussd;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_NETWORK)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_send_ussd;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_USSD_STRING,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->ussd_string,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
}
static void destroy_setup_call(struct stk_command *command)
{
l_free(command->setup_call.alpha_id_usr_cfm);
l_free(command->setup_call.addr.number);
l_free(command->setup_call.alpha_id_call_setup);
}
static enum stk_command_parse_result parse_setup_call(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_setup_call *obj = &command->setup_call;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_NETWORK)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_setup_call;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id_usr_cfm,
STK_DATA_OBJECT_TYPE_ADDRESS,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->addr,
STK_DATA_OBJECT_TYPE_CCP, 0,
&obj->ccp,
STK_DATA_OBJECT_TYPE_SUBADDRESS, 0,
&obj->subaddr,
STK_DATA_OBJECT_TYPE_DURATION, 0,
&obj->duration,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id_usr_cfm,
STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id_call_setup,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id_call_setup,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr_usr_cfm,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr_call_setup,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id_usr_cfm, obj->icon_id_usr_cfm.id);
CHECK_TEXT_AND_ICON(obj->alpha_id_call_setup,
obj->icon_id_call_setup.id);
return status;
}
static void destroy_refresh(struct stk_command *command)
{
l_queue_destroy(command->refresh.file_list, l_free);
l_free(command->refresh.alpha_id);
}
static enum stk_command_parse_result parse_refresh(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_refresh *obj = &command->refresh;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_refresh;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_FILE_LIST, 0,
&obj->file_list,
STK_DATA_OBJECT_TYPE_AID, 0,
&obj->aid,
STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static enum stk_command_parse_result parse_polling_off(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return STK_PARSE_RESULT_OK;
}
static enum stk_command_parse_result parse_provide_local_info(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return STK_PARSE_RESULT_OK;
}
static enum stk_command_parse_result parse_setup_event_list(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_setup_event_list *obj = &command->setup_event_list;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_EVENT_LIST,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->event_list,
STK_DATA_OBJECT_TYPE_INVALID);
}
static enum stk_command_parse_result parse_perform_card_apdu(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_perform_card_apdu *obj = &command->perform_card_apdu;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if ((command->dst < STK_DEVICE_IDENTITY_TYPE_CARD_READER_0) ||
(command->dst > STK_DEVICE_IDENTITY_TYPE_CARD_READER_7))
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_C_APDU,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->c_apdu,
STK_DATA_OBJECT_TYPE_INVALID);
}
static enum stk_command_parse_result parse_power_off_card(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if ((command->dst < STK_DEVICE_IDENTITY_TYPE_CARD_READER_0) ||
(command->dst > STK_DEVICE_IDENTITY_TYPE_CARD_READER_7))
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return STK_PARSE_RESULT_OK;
}
static enum stk_command_parse_result parse_power_on_card(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if ((command->dst < STK_DEVICE_IDENTITY_TYPE_CARD_READER_0) ||
(command->dst > STK_DEVICE_IDENTITY_TYPE_CARD_READER_7))
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return STK_PARSE_RESULT_OK;
}
static enum stk_command_parse_result parse_get_reader_status(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
switch (command->qualifier) {
case STK_QUALIFIER_TYPE_CARD_READER_STATUS:
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
break;
case STK_QUALIFIER_TYPE_CARD_READER_ID:
if ((command->dst < STK_DEVICE_IDENTITY_TYPE_CARD_READER_0) ||
(command->dst >
STK_DEVICE_IDENTITY_TYPE_CARD_READER_7))
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
break;
default:
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
}
return STK_PARSE_RESULT_OK;
}
static enum stk_command_parse_result parse_timer_mgmt(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_timer_mgmt *obj = &command->timer_mgmt;
enum stk_data_object_flag value_flags = 0;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if ((command->qualifier & 3) == 0) /* Start a timer */
value_flags = DATAOBJ_FLAG_MANDATORY;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_TIMER_ID,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->timer_id,
STK_DATA_OBJECT_TYPE_TIMER_VALUE, value_flags,
&obj->timer_value,
STK_DATA_OBJECT_TYPE_INVALID);
}
static void destroy_setup_idle_mode_text(struct stk_command *command)
{
l_free(command->setup_idle_mode_text.text);
}
static enum stk_command_parse_result parse_setup_idle_mode_text(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_setup_idle_mode_text *obj =
&command->setup_idle_mode_text;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_setup_idle_mode_text;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_TEXT,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->text,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->text, obj->icon_id.id);
return status;
}
static void destroy_run_at_command(struct stk_command *command)
{
l_free(command->run_at_command.alpha_id);
l_free(command->run_at_command.at_command);
}
static enum stk_command_parse_result parse_run_at_command(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_run_at_command *obj = &command->run_at_command;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_run_at_command;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_AT_COMMAND,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->at_command,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static void destroy_send_dtmf(struct stk_command *command)
{
l_free(command->send_dtmf.alpha_id);
l_free(command->send_dtmf.dtmf);
}
static enum stk_command_parse_result parse_send_dtmf(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_send_dtmf *obj = &command->send_dtmf;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_NETWORK)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_send_dtmf;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_DTMF_STRING,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->dtmf,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static enum stk_command_parse_result parse_language_notification(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_language_notification *obj =
&command->language_notification;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_LANGUAGE, 0,
&obj->language,
STK_DATA_OBJECT_TYPE_INVALID);
}
static void destroy_launch_browser(struct stk_command *command)
{
l_free(command->launch_browser.url);
l_free(command->launch_browser.bearer.array);
l_queue_destroy(command->launch_browser.prov_file_refs, l_free);
l_free(command->launch_browser.text_gateway_proxy_id);
l_free(command->launch_browser.alpha_id);
l_free(command->launch_browser.network_name.array);
l_free(command->launch_browser.text_usr);
l_free(command->launch_browser.text_passwd);
}
static enum stk_command_parse_result parse_launch_browser(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_launch_browser *obj = &command->launch_browser;
if (command->qualifier > 3 || command->qualifier == 1)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_launch_browser;
return parse_dataobj(iter,
STK_DATA_OBJECT_TYPE_BROWSER_ID, 0,
&obj->browser_id,
STK_DATA_OBJECT_TYPE_URL,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->url,
STK_DATA_OBJECT_TYPE_BEARER, 0,
&obj->bearer,
STK_DATA_OBJECT_TYPE_PROVISIONING_FILE_REF,
DATAOBJ_FLAG_LIST,
&obj->prov_file_refs,
STK_DATA_OBJECT_TYPE_TEXT, 0,
&obj->text_gateway_proxy_id,
STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_NETWORK_ACCESS_NAME, 0,
&obj->network_name,
STK_DATA_OBJECT_TYPE_TEXT, 0,
&obj->text_usr,
STK_DATA_OBJECT_TYPE_TEXT, 0,
&obj->text_passwd,
STK_DATA_OBJECT_TYPE_INVALID);
}
static void destroy_open_channel(struct stk_command *command)
{
l_free(command->open_channel.alpha_id);
l_free(command->open_channel.apn);
l_free(command->open_channel.text_usr);
l_free(command->open_channel.text_passwd);
}
static enum stk_command_parse_result parse_open_channel(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_open_channel *obj = &command->open_channel;
enum stk_command_parse_result status;
if (command->qualifier >= 0x08)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_open_channel;
/*
* parse the Open Channel data objects related to packet data service
* bearer
*/
status = parse_dataobj(iter,
STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_BEARER_DESCRIPTION,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->bearer_desc,
STK_DATA_OBJECT_TYPE_BUFFER_SIZE,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->buf_size,
STK_DATA_OBJECT_TYPE_NETWORK_ACCESS_NAME, 0,
&obj->apn,
STK_DATA_OBJECT_TYPE_OTHER_ADDRESS, 0,
&obj->local_addr,
STK_DATA_OBJECT_TYPE_TEXT, 0,
&obj->text_usr,
STK_DATA_OBJECT_TYPE_TEXT, 0,
&obj->text_passwd,
STK_DATA_OBJECT_TYPE_UICC_TE_INTERFACE, 0,
&obj->uti,
STK_DATA_OBJECT_TYPE_OTHER_ADDRESS, 0,
&obj->data_dest_addr,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static void destroy_close_channel(struct stk_command *command)
{
l_free(command->close_channel.alpha_id);
}
static enum stk_command_parse_result parse_close_channel(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_close_channel *obj = &command->close_channel;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if ((command->dst < STK_DEVICE_IDENTITY_TYPE_CHANNEL_1) ||
(command->dst > STK_DEVICE_IDENTITY_TYPE_CHANNEL_7))
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_close_channel;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static void destroy_receive_data(struct stk_command *command)
{
l_free(command->receive_data.alpha_id);
}
static enum stk_command_parse_result parse_receive_data(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_receive_data *obj = &command->receive_data;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if ((command->dst < STK_DEVICE_IDENTITY_TYPE_CHANNEL_1) ||
(command->dst > STK_DEVICE_IDENTITY_TYPE_CHANNEL_7))
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_receive_data;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_CHANNEL_DATA_LENGTH,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->data_len,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static void destroy_send_data(struct stk_command *command)
{
l_free(command->send_data.alpha_id);
l_free(command->send_data.data.array);
}
static enum stk_command_parse_result parse_send_data(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_send_data *obj = &command->send_data;
enum stk_command_parse_result status;
if (command->qualifier > STK_SEND_DATA_IMMEDIATELY)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if ((command->dst < STK_DEVICE_IDENTITY_TYPE_CHANNEL_1) ||
(command->dst > STK_DEVICE_IDENTITY_TYPE_CHANNEL_7))
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_send_data;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_CHANNEL_DATA,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->data,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static enum stk_command_parse_result parse_get_channel_status(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return STK_PARSE_RESULT_OK;
}
static void destroy_service_search(struct stk_command *command)
{
l_free(command->service_search.alpha_id);
l_free(command->service_search.serv_search.ser_search);
l_free(command->service_search.dev_filter.dev_filter);
}
static enum stk_command_parse_result parse_service_search(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_service_search *obj = &command->service_search;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_service_search;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_SERVICE_SEARCH,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->serv_search,
STK_DATA_OBJECT_TYPE_DEVICE_FILTER, 0,
&obj->dev_filter,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
}
static void destroy_get_service_info(struct stk_command *command)
{
l_free(command->get_service_info.alpha_id);
l_free(command->get_service_info.attr_info.attr_info);
}
static enum stk_command_parse_result parse_get_service_info(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_get_service_info *obj = &command->get_service_info;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_get_service_info;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_ATTRIBUTE_INFO,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->attr_info,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
}
static void destroy_declare_service(struct stk_command *command)
{
l_free(command->declare_service.serv_rec.serv_rec);
}
static enum stk_command_parse_result parse_declare_service(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_declare_service *obj = &command->declare_service;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_declare_service;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_SERVICE_RECORD,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->serv_rec,
STK_DATA_OBJECT_TYPE_UICC_TE_INTERFACE, 0,
&obj->intf,
STK_DATA_OBJECT_TYPE_INVALID);
}
static enum stk_command_parse_result parse_set_frames(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_set_frames *obj = &command->set_frames;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_FRAME_ID,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_FRAME_LAYOUT, 0,
&obj->frame_layout,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id_default,
STK_DATA_OBJECT_TYPE_INVALID);
}
static enum stk_command_parse_result parse_get_frames_status(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return STK_PARSE_RESULT_OK;
}
static void destroy_retrieve_mms(struct stk_command *command)
{
l_free(command->retrieve_mms.alpha_id);
l_queue_destroy(command->retrieve_mms.mms_rec_files, l_free);
}
static enum stk_command_parse_result parse_retrieve_mms(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_retrieve_mms *obj = &command->retrieve_mms;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_NETWORK)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_retrieve_mms;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_MMS_REFERENCE,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->mms_ref,
STK_DATA_OBJECT_TYPE_FILE_LIST,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->mms_rec_files,
STK_DATA_OBJECT_TYPE_MMS_CONTENT_ID,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->mms_content_id,
STK_DATA_OBJECT_TYPE_MMS_ID, 0,
&obj->mms_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static void destroy_submit_mms(struct stk_command *command)
{
l_free(command->submit_mms.alpha_id);
l_queue_destroy(command->submit_mms.mms_subm_files, l_free);
}
static enum stk_command_parse_result parse_submit_mms(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_submit_mms *obj = &command->submit_mms;
enum stk_command_parse_result status;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_NETWORK)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_submit_mms;
status = parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ALPHA_ID, 0,
&obj->alpha_id,
STK_DATA_OBJECT_TYPE_ICON_ID, 0,
&obj->icon_id,
STK_DATA_OBJECT_TYPE_FILE_LIST,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->mms_subm_files,
STK_DATA_OBJECT_TYPE_MMS_ID, 0,
&obj->mms_id,
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE, 0,
&obj->text_attr,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
CHECK_TEXT_AND_ICON(obj->alpha_id, obj->icon_id.id);
return status;
}
static void destroy_display_mms(struct stk_command *command)
{
l_queue_destroy(command->display_mms.mms_subm_files, l_free);
}
static enum stk_command_parse_result parse_display_mms(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_display_mms *obj = &command->display_mms;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
command->destructor = destroy_display_mms;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_FILE_LIST,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->mms_subm_files,
STK_DATA_OBJECT_TYPE_MMS_ID,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->mms_id,
STK_DATA_OBJECT_TYPE_IMMEDIATE_RESPONSE, 0,
&obj->imd_resp,
STK_DATA_OBJECT_TYPE_FRAME_ID, 0,
&obj->frame_id,
STK_DATA_OBJECT_TYPE_INVALID);
}
static enum stk_command_parse_result parse_activate(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
struct stk_command_activate *obj = &command->activate;
if (command->src != STK_DEVICE_IDENTITY_TYPE_UICC)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
if (command->dst != STK_DEVICE_IDENTITY_TYPE_TERMINAL)
return STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
return parse_dataobj(iter, STK_DATA_OBJECT_TYPE_ACTIVATE_DESCRIPTOR,
DATAOBJ_FLAG_MANDATORY | DATAOBJ_FLAG_MINIMUM,
&obj->actv_desc,
STK_DATA_OBJECT_TYPE_INVALID);
}
static enum stk_command_parse_result parse_command_body(
struct stk_command *command,
struct comprehension_tlv_iter *iter)
{
switch (command->type) {
case STK_COMMAND_TYPE_DISPLAY_TEXT:
return parse_display_text(command, iter);
case STK_COMMAND_TYPE_GET_INKEY:
return parse_get_inkey(command, iter);
case STK_COMMAND_TYPE_GET_INPUT:
return parse_get_input(command, iter);
case STK_COMMAND_TYPE_MORE_TIME:
return parse_more_time(command, iter);
case STK_COMMAND_TYPE_PLAY_TONE:
return parse_play_tone(command, iter);
case STK_COMMAND_TYPE_POLL_INTERVAL:
return parse_poll_interval(command, iter);
case STK_COMMAND_TYPE_SETUP_MENU:
return parse_setup_menu(command, iter);
case STK_COMMAND_TYPE_SELECT_ITEM:
return parse_select_item(command, iter);
case STK_COMMAND_TYPE_SEND_SMS:
return parse_send_sms(command, iter);
case STK_COMMAND_TYPE_SEND_SS:
return parse_send_ss(command, iter);
case STK_COMMAND_TYPE_SEND_USSD:
return parse_send_ussd(command, iter);
case STK_COMMAND_TYPE_SETUP_CALL:
return parse_setup_call(command, iter);
case STK_COMMAND_TYPE_REFRESH:
return parse_refresh(command, iter);
case STK_COMMAND_TYPE_POLLING_OFF:
return parse_polling_off(command, iter);
case STK_COMMAND_TYPE_PROVIDE_LOCAL_INFO:
return parse_provide_local_info(command, iter);
case STK_COMMAND_TYPE_SETUP_EVENT_LIST:
return parse_setup_event_list(command, iter);
case STK_COMMAND_TYPE_PERFORM_CARD_APDU:
return parse_perform_card_apdu(command, iter);
case STK_COMMAND_TYPE_POWER_OFF_CARD:
return parse_power_off_card(command, iter);
case STK_COMMAND_TYPE_POWER_ON_CARD:
return parse_power_on_card(command, iter);
case STK_COMMAND_TYPE_GET_READER_STATUS:
return parse_get_reader_status(command, iter);
case STK_COMMAND_TYPE_TIMER_MANAGEMENT:
return parse_timer_mgmt(command, iter);
case STK_COMMAND_TYPE_SETUP_IDLE_MODE_TEXT:
return parse_setup_idle_mode_text(command, iter);
case STK_COMMAND_TYPE_RUN_AT_COMMAND:
return parse_run_at_command(command, iter);
case STK_COMMAND_TYPE_SEND_DTMF:
return parse_send_dtmf(command, iter);
case STK_COMMAND_TYPE_LANGUAGE_NOTIFICATION:
return parse_language_notification(command, iter);
case STK_COMMAND_TYPE_LAUNCH_BROWSER:
return parse_launch_browser(command, iter);
case STK_COMMAND_TYPE_OPEN_CHANNEL:
return parse_open_channel(command, iter);
case STK_COMMAND_TYPE_CLOSE_CHANNEL:
return parse_close_channel(command, iter);
case STK_COMMAND_TYPE_RECEIVE_DATA:
return parse_receive_data(command, iter);
case STK_COMMAND_TYPE_SEND_DATA:
return parse_send_data(command, iter);
case STK_COMMAND_TYPE_GET_CHANNEL_STATUS:
return parse_get_channel_status(command, iter);
case STK_COMMAND_TYPE_SERVICE_SEARCH:
return parse_service_search(command, iter);
case STK_COMMAND_TYPE_GET_SERVICE_INFO:
return parse_get_service_info(command, iter);
case STK_COMMAND_TYPE_DECLARE_SERVICE:
return parse_declare_service(command, iter);
case STK_COMMAND_TYPE_SET_FRAMES:
return parse_set_frames(command, iter);
case STK_COMMAND_TYPE_GET_FRAMES_STATUS:
return parse_get_frames_status(command, iter);
case STK_COMMAND_TYPE_RETRIEVE_MMS:
return parse_retrieve_mms(command, iter);
case STK_COMMAND_TYPE_SUBMIT_MMS:
return parse_submit_mms(command, iter);
case STK_COMMAND_TYPE_DISPLAY_MMS:
return parse_display_mms(command, iter);
case STK_COMMAND_TYPE_ACTIVATE:
return parse_activate(command, iter);
default:
return STK_PARSE_RESULT_TYPE_NOT_UNDERSTOOD;
};
}
struct stk_command *stk_command_new_from_pdu(const uint8_t *pdu,
unsigned int len)
{
struct ber_tlv_iter ber;
struct comprehension_tlv_iter iter;
const uint8_t *data;
struct stk_command *command;
ber_tlv_iter_init(&ber, pdu, len);
if (ber_tlv_iter_next(&ber) != TRUE)
return NULL;
/* We should be wrapped in a Proactive UICC Command Tag 0xD0 */
if (ber_tlv_iter_get_short_tag(&ber) != 0xD0)
return NULL;
ber_tlv_iter_recurse_comprehension(&ber, &iter);
/*
* Now parse actual command details, they come in order with
* Command Details TLV first, followed by Device Identities TLV
*/
if (comprehension_tlv_iter_next(&iter) != TRUE)
return NULL;
if (comprehension_tlv_iter_get_tag(&iter) !=
STK_DATA_OBJECT_TYPE_COMMAND_DETAILS)
return NULL;
if (comprehension_tlv_iter_get_length(&iter) != 0x03)
return NULL;
data = comprehension_tlv_iter_get_data(&iter);
command = g_new0(struct stk_command, 1);
command->number = data[0];
command->type = data[1];
command->qualifier = data[2];
if (comprehension_tlv_iter_next(&iter) != TRUE) {
command->status = STK_PARSE_RESULT_MISSING_VALUE;
goto out;
}
if (comprehension_tlv_iter_get_tag(&iter) !=
STK_DATA_OBJECT_TYPE_DEVICE_IDENTITIES) {
command->status = STK_PARSE_RESULT_MISSING_VALUE;
goto out;
}
if (comprehension_tlv_iter_get_length(&iter) != 0x02) {
command->status = STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD;
goto out;
}
data = comprehension_tlv_iter_get_data(&iter);
command->src = data[0];
command->dst = data[1];
command->status = parse_command_body(command, &iter);
out:
return command;
}
void stk_command_free(struct stk_command *command)
{
if (command->destructor)
command->destructor(command);
g_free(command);
}
static bool stk_tlv_builder_init(struct stk_tlv_builder *iter,
uint8_t *pdu, unsigned int size)
{
iter->value = NULL;
iter->len = 0;
return comprehension_tlv_builder_init(&iter->ctlv, pdu, size);
}
static bool stk_tlv_builder_recurse(struct stk_tlv_builder *iter,
struct ber_tlv_builder *btlv,
uint8_t tag)
{
iter->value = NULL;
iter->len = 0;
if (ber_tlv_builder_next(btlv, tag >> 6, (tag >> 5) & 1,
tag & 0x1f) != TRUE)
return false;
return ber_tlv_builder_recurse_comprehension(btlv, &iter->ctlv);
}
static bool stk_tlv_builder_open_container(struct stk_tlv_builder *iter,
bool cr,
uint8_t shorttag,
bool relocatable)
{
if (comprehension_tlv_builder_next(&iter->ctlv, cr, shorttag) != TRUE)
return false;
iter->len = 0;
iter->max_len = relocatable ? 0xff : 0x7f;
if (comprehension_tlv_builder_set_length(&iter->ctlv, iter->max_len) !=
TRUE)
return false;
iter->value = comprehension_tlv_builder_get_data(&iter->ctlv);
return true;
}
static bool stk_tlv_builder_close_container(struct stk_tlv_builder *iter)
{
return comprehension_tlv_builder_set_length(&iter->ctlv, iter->len);
}
static unsigned int stk_tlv_builder_get_length(struct stk_tlv_builder *iter)
{
return comprehension_tlv_builder_get_data(&iter->ctlv) -
iter->ctlv.pdu + iter->len;
}
static bool stk_tlv_builder_append_byte(struct stk_tlv_builder *iter,
uint8_t num)
{
if (iter->len >= iter->max_len)
return false;
iter->value[iter->len++] = num;
return true;
}
static bool stk_tlv_builder_append_short(struct stk_tlv_builder *iter,
uint16_t num)
{
if (iter->len + 2 > iter->max_len)
return false;
iter->value[iter->len++] = num >> 8;
iter->value[iter->len++] = num & 0xff;
return true;
}
static bool stk_tlv_builder_append_gsm_packed(struct stk_tlv_builder *iter,
const char *text)
{
unsigned int len;
uint8_t *gsm;
long written = 0;
if (text == NULL)
return true;
len = strlen(text);
gsm = convert_utf8_to_gsm(text, len, NULL, &written, 0);
if (gsm == NULL && len > 0)
return false;
if (iter->len + (written * 7 + 7) / 8 >= iter->max_len) {
l_free(gsm);
return false;
}
pack_7bit_own_buf(gsm, len, 0, false, &written, 0,
iter->value + iter->len + 1);
l_free(gsm);
if (written < 1 && len > 0)
return false;
iter->value[iter->len++] = 0x00;
iter->len += written;
return true;
}
static bool stk_tlv_builder_append_gsm_unpacked(struct stk_tlv_builder *iter,
const char *text)
{
unsigned int len;
uint8_t *gsm;
long written = 0;
if (text == NULL)
return true;
len = strlen(text);
gsm = convert_utf8_to_gsm(text, len, NULL, &written, 0);
if (gsm == NULL && len > 0)
return false;
if (iter->len + written >= iter->max_len) {
l_free(gsm);
return false;
}
iter->value[iter->len++] = 0x04;
memcpy(iter->value + iter->len, gsm, written);
iter->len += written;
l_free(gsm);
return true;
}
static bool stk_tlv_builder_append_ucs2(struct stk_tlv_builder *iter,
const char *text)
{
L_AUTO_FREE_VAR(uint8_t *, ucs2);
size_t ucs2_len;
ucs2 = l_utf8_to_ucs2be(text, &ucs2_len);
if (!ucs2)
return false;
/* Don't include terminating NULL */
ucs2_len -= 2;
if (iter->len + ucs2_len >= iter->max_len)
return false;
iter->value[iter->len++] = 0x08;
memcpy(iter->value + iter->len, ucs2, ucs2_len);
iter->len += ucs2_len;
return true;
}
static bool stk_tlv_builder_append_text(struct stk_tlv_builder *iter,
int dcs, const char *text)
{
bool ret;
switch (dcs) {
case 0x00:
return stk_tlv_builder_append_gsm_packed(iter, text);
case 0x04:
return stk_tlv_builder_append_gsm_unpacked(iter, text);
case 0x08:
return stk_tlv_builder_append_ucs2(iter, text);
case -1:
ret = stk_tlv_builder_append_gsm_unpacked(iter, text);
if (ret)
return ret;
return stk_tlv_builder_append_ucs2(iter, text);
}
return false;
}
static inline bool stk_tlv_builder_append_bytes(struct stk_tlv_builder *iter,
const uint8_t *data,
unsigned int length)
{
if (iter->len + length > iter->max_len)
return false;
memcpy(iter->value + iter->len, data, length);
iter->len += length;
return true;
}
/* Described in TS 102.223 Section 8.1 */
static bool build_dataobj_address(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_address *addr = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_ADDRESS;
unsigned int len;
uint8_t number[128];
if (addr->number == NULL)
return true;
len = (strlen(addr->number) + 1) / 2;
sim_encode_bcd_number(addr->number, number);
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, addr->ton_npi) &&
stk_tlv_builder_append_bytes(tlv, number, len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.2 */
static bool build_dataobj_alpha_id(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
uint8_t tag = STK_DATA_OBJECT_TYPE_ALPHA_ID;
int len;
uint8_t *string;
if (data == NULL)
return true;
if (strlen(data) == 0)
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_close_container(tlv);
string = utf8_to_sim_string(data, -1, &len);
if (string == NULL)
return false;
return stk_tlv_builder_open_container(tlv, cr, tag, true) &&
stk_tlv_builder_append_bytes(tlv, string, len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.3 */
static bool build_dataobj_subaddress(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_subaddress *sa = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_SUBADDRESS;
if (!sa->has_subaddr)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, sa->subaddr, sa->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.4 */
static bool build_dataobj_ccp(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_ccp *ccp = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_CCP;
if (ccp->len == 0)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, ccp->len) &&
stk_tlv_builder_append_bytes(tlv, ccp->ccp, ccp->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.5 */
static bool build_dataobj_cbs_page(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct cbs *page = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_CBS_PAGE;
uint8_t pdu[88];
if (cbs_encode(page, NULL, pdu) == FALSE)
return false;
return stk_tlv_builder_open_container(tlv, cr, tag, true) &&
stk_tlv_builder_append_bytes(tlv, pdu, 88) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.6 */
static bool build_dataobj_item_id(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const uint8_t *item_id = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_ITEM_ID;
if (*item_id == 0)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, *item_id) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.8 */
static bool build_dataobj_duration(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_duration *duration = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_DURATION;
if (duration->interval == 0x00)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, duration->unit) &&
stk_tlv_builder_append_byte(tlv, duration->interval) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.12 */
static bool build_dataobj_result(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_result *result = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_RESULT;
if (!stk_tlv_builder_open_container(tlv, cr, tag, false))
return false;
if (!stk_tlv_builder_append_byte(tlv, result->type))
return false;
if (result->additional_len > 0)
if (!stk_tlv_builder_append_bytes(tlv, result->additional,
result->additional_len))
return false;
return stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.13 */
static bool build_dataobj_gsm_sms_tpdu(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct sms_deliver *msg = data;
struct sms sms;
uint8_t tag = STK_DATA_OBJECT_TYPE_GSM_SMS_TPDU;
uint8_t tpdu[165];
int tpdu_len;
sms.type = SMS_TYPE_DELIVER;
memset(&sms.sc_addr, 0, sizeof(sms.sc_addr));
memcpy(&sms.deliver, msg, sizeof(sms.deliver));
if (sms_encode(&sms, NULL, &tpdu_len, tpdu) == FALSE)
return false;
return stk_tlv_builder_open_container(tlv, cr, tag, true) &&
stk_tlv_builder_append_bytes(tlv, tpdu + 1, tpdu_len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.14 */
static bool build_dataobj_ss_string(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_address *addr = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_SS_STRING;
unsigned int len;
uint8_t number[128];
if (addr->number == NULL)
return true;
len = (strlen(addr->number) + 1) / 2;
sim_encode_bcd_number(addr->number, number);
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, addr->ton_npi) &&
stk_tlv_builder_append_bytes(tlv, number, len) &&
stk_tlv_builder_close_container(tlv);
}
/* Defined in TS 102.223 Section 8.15 */
static bool build_dataobj_text(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_answer_text *text = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_TEXT;
bool ret;
if (text->text == NULL && !text->yesno)
return true;
if (!stk_tlv_builder_open_container(tlv, cr, tag, true))
return false;
if (text->yesno) {
/*
* Section 6.8.5:
* When the terminal issues [...] command qualifier set
* to "Yes/No", it shall supply the value "01" when the
* answer is "positive" and the value '00' when the
* answer is "negative" in the text string data object.
*/
if (!stk_tlv_builder_append_byte(tlv, 0x04))
return false;
ret = stk_tlv_builder_append_byte(tlv,
text->text ? 0x01 : 0x00);
} else if (text->packed)
ret = stk_tlv_builder_append_gsm_packed(tlv, text->text);
else
ret = stk_tlv_builder_append_text(tlv, -1, text->text);
if (!ret)
return ret;
return stk_tlv_builder_close_container(tlv);
}
/* Defined in TS 102.223 Section 8.15 - USSD specific case*/
static bool build_dataobj_ussd_text(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_ussd_text *text = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_TEXT;
if (!text->has_text)
return true;
if (!stk_tlv_builder_open_container(tlv, cr, tag, true))
return false;
if (text->len > 0) {
if (!stk_tlv_builder_append_byte(tlv, text->dcs))
return false;
if (!stk_tlv_builder_append_bytes(tlv, text->text, text->len))
return false;
}
return stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.17 */
static bool build_dataobj_ussd_string(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_ussd_string *ussd = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_USSD_STRING;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, ussd->dcs) &&
stk_tlv_builder_append_bytes(tlv, ussd->string, ussd->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.18 */
static bool build_dataobj_file_list(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
struct l_queue *fl = (void *) data;
const struct l_queue_entry *entry = l_queue_get_entries(fl);
const struct stk_file *file;
uint8_t tag = STK_DATA_OBJECT_TYPE_FILE_LIST;
if (!stk_tlv_builder_open_container(tlv, cr, tag, true))
return false;
if (!stk_tlv_builder_append_byte(tlv, l_queue_length(fl)))
return false;
for (; entry; entry = entry->next) {
file = entry->data;
if (!stk_tlv_builder_append_bytes(tlv, file->file, file->len))
return false;
}
return stk_tlv_builder_close_container(tlv);
}
/* Shortcut for a single File element */
static bool build_dataobj_file(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
struct l_queue *fl = l_queue_new();
bool ret;
l_queue_push_tail(fl, (void *) data);
ret = build_dataobj_file_list(tlv, fl, cr);
l_queue_destroy(fl, NULL);
return ret;
}
/* Described in TS 102.223 Section 8.19 */
static bool build_dataobj_location_info(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_location_info *li = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_LOCATION_INFO;
uint8_t mccmnc[3];
if (li->mcc[0] == '\0')
return true;
sim_encode_mcc_mnc(mccmnc, li->mcc, li->mnc);
if (!stk_tlv_builder_open_container(tlv, cr, tag, false))
return false;
if (!stk_tlv_builder_append_bytes(tlv, mccmnc, 3))
return false;
if (!stk_tlv_builder_append_short(tlv, li->lac_tac))
return false;
if (li->has_ci && !stk_tlv_builder_append_short(tlv, li->ci))
return false;
if (li->has_ext_ci && !stk_tlv_builder_append_short(tlv, li->ext_ci))
return false;
if (li->has_eutran_ci) {
if (!stk_tlv_builder_append_short(tlv, li->eutran_ci >> 12))
return false;
if (!stk_tlv_builder_append_short(tlv,
(li->eutran_ci << 4) | 0xf))
return false;
}
return stk_tlv_builder_close_container(tlv);
}
static bool build_empty_dataobj_location_info(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
uint8_t tag = STK_DATA_OBJECT_TYPE_LOCATION_INFO;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_close_container(tlv);
}
/*
* Described in TS 102.223 Section 8.20
*
* See format note in parse_dataobj_imei.
*/
static bool build_dataobj_imei(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
char byte0[3];
const char *imei = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_IMEI;
uint8_t value[8];
if (imei == NULL)
return true;
if (strlen(imei) != 15)
return false;
byte0[0] = '*';
byte0[1] = imei[0];
byte0[2] = '\0';
sim_encode_bcd_number(byte0, value);
sim_encode_bcd_number(imei + 1, value + 1);
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, value, 8) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.21 */
static bool build_dataobj_help_request(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const bool *help = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_HELP_REQUEST;
if (*help != true)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.22 */
static bool build_dataobj_network_measurement_results(
struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_common_byte_array *nmr = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_NETWORK_MEASUREMENT_RESULTS;
if (!stk_tlv_builder_open_container(tlv, cr, tag, false))
return false;
if (nmr->len > 0 && !stk_tlv_builder_append_bytes(tlv,
nmr->array, nmr->len))
return false;
return stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.25 */
static bool build_dataobj_event_list(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_event_list *list = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_EVENT_LIST;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, list->list, list->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Shortcut for a single Event type */
static bool build_dataobj_event_type(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_event_list list = {
.list = { *(enum stk_event_type *) data },
.len = 1,
};
return build_dataobj_event_list(tlv, &list, cr);
}
/* Described in TS 102.223 Section 8.26 */
static bool build_dataobj_cause(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_cause *cause = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_CAUSE;
if (!cause->has_cause)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, cause->cause, cause->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.27 */
static bool build_dataobj_location_status(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const enum stk_service_state *state = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_LOCATION_STATUS;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, *state) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.28 */
static bool build_dataobj_transaction_ids(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_transaction_id *id = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_TRANSACTION_ID;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, id->list, id->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Shortcut for a single Transaction ID */
static bool build_dataobj_transaction_id(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_transaction_id ids = {
.list = { *(uint8_t *) data },
.len = 1,
};
return build_dataobj_transaction_ids(tlv, &ids, cr);
}
/* Described in 3GPP 31.111 Section 8.29 */
static bool build_dataobj_bcch_channel_list(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_bcch_channel_list *list = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_BCCH_CHANNEL_LIST;
unsigned int i, bytes, pos, shift;
uint8_t value;
if (!list->has_list)
return true;
if (!stk_tlv_builder_open_container(tlv, cr, tag, true))
return false;
bytes = (list->num * 10 + 7) / 8;
for (i = 0; i < bytes; i++) {
pos = (i * 8 + 7) / 10;
shift = pos * 10 + 10 - i * 8 - 8;
value = 0;
if (pos < list->num)
value |= list->channels[pos] >> shift;
if (shift > 2)
value |= list->channels[pos - 1] << (10 - shift);
if (!stk_tlv_builder_append_byte(tlv, value))
return false;
}
return stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.30 */
static bool build_dataobj_cc_requested_action(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_common_byte_array *action = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_CALL_CONTROL_REQUESTED_ACTION;
if (action->array == NULL)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, action->array, action->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.33 */
static bool build_dataobj_card_reader_status(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_reader_status *status = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_CARD_READER_STATUS;
uint8_t byte;
byte = status->id |
(status->removable << 3) |
(status->present << 4) |
(status->id1_size << 5) |
(status->card_present << 6) |
(status->card_powered << 7);
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, byte) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.37 */
static bool build_dataobj_timer_id(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const uint8_t *id = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_TIMER_ID;
if (id[0] == 0)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, id[0]) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.38 */
static bool build_dataobj_timer_value(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_timer_value *value = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_TIMER_VALUE;
if (!value->has_value)
return true;
#define TO_BCD(bin) ((((bin) / 10) & 0xf) | (((bin) % 10) << 4))
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, TO_BCD(value->hour)) &&
stk_tlv_builder_append_byte(tlv, TO_BCD(value->minute)) &&
stk_tlv_builder_append_byte(tlv, TO_BCD(value->second)) &&
stk_tlv_builder_close_container(tlv);
#undef TO_BCD
}
/* Described in TS 102.223 Section 8.39 */
static bool build_dataobj_datetime_timezone(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct sms_scts *scts = data;
uint8_t value[7];
int offset = 0;
uint8_t tag = STK_DATA_OBJECT_TYPE_DATETIME_TIMEZONE;
if (scts->month == 0 && scts->day == 0)
return true;
if (sms_encode_scts(scts, value, &offset) != TRUE)
return false;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, value, 7) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.41 */
static bool build_dataobj_at_response(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
uint8_t tag = STK_DATA_OBJECT_TYPE_AT_RESPONSE;
int len;
if (data == NULL)
return true;
/*
* "If the AT Response string is longer than the maximum length
* capable of being transmitted to the UICC then the AT Response
* string shall be truncated to this length by the terminal."
*/
len = strlen(data);
if (len > 240) /* Safe pick */
len = 240;
return stk_tlv_builder_open_container(tlv, cr, tag, true) &&
stk_tlv_builder_append_bytes(tlv, data, len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.42 */
static bool build_dataobj_bc_repeat(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
uint8_t tag = STK_DATA_OBJECT_TYPE_BC_REPEAT_INDICATOR;
const struct stk_bc_repeat *bcr = data;
if (!bcr->has_bc_repeat)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, true) &&
stk_tlv_builder_append_byte(tlv, bcr->value) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.45 */
static bool build_dataobj_language(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
uint8_t tag = STK_DATA_OBJECT_TYPE_LANGUAGE;
if (data == NULL)
return true;
/*
* Coded as two GSM 7-bit characters with eighth bit clear. Since
* ISO 639-2 codes use only english alphabet letters, no conversion
* from UTF-8 to GSM is needed.
*/
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, data, 2) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in 3GPP TS 31.111 Section 8.46 */
static bool build_dataobj_timing_advance(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_timing_advance *tadv = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_TIMING_ADVANCE;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, tadv->status) &&
stk_tlv_builder_append_byte(tlv, tadv->advance) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.51 */
static bool build_dataobj_browser_termination_cause(
struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const enum stk_browser_termination_cause *cause = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_BROWSER_TERMINATION_CAUSE;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, *cause) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.52 */
static bool build_dataobj_bearer_description(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_bearer_description *bd = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_BEARER_DESCRIPTION;
if (bd->type != STK_BEARER_TYPE_GPRS_UTRAN)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, bd->type) &&
stk_tlv_builder_append_byte(tlv,
bd->gprs.precedence) &&
stk_tlv_builder_append_byte(tlv,
bd->gprs.delay) &&
stk_tlv_builder_append_byte(tlv,
bd->gprs.reliability) &&
stk_tlv_builder_append_byte(tlv,
bd->gprs.peak) &&
stk_tlv_builder_append_byte(tlv,
bd->gprs.mean) &&
stk_tlv_builder_append_byte(tlv,
bd->gprs.pdp_type) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.53 */
static bool build_dataobj_channel_data(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_common_byte_array *cd = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_CHANNEL_DATA;
return stk_tlv_builder_open_container(tlv, cr, tag, true) &&
stk_tlv_builder_append_bytes(tlv, cd->array, cd->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.54 */
static bool build_dataobj_channel_data_length(
struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const uint16_t *length = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_CHANNEL_DATA_LENGTH;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, MIN(*length, 255)) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.55 */
static bool build_dataobj_buffer_size(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const uint16_t *buf_size = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_BUFFER_SIZE;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_short(tlv, *buf_size) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.56 */
static bool build_dataobj_channel_status(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_channel *channel = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_CHANNEL_STATUS;
uint8_t byte[2];
switch (channel->status) {
case STK_CHANNEL_PACKET_DATA_SERVICE_NOT_ACTIVATED:
case STK_CHANNEL_TCP_IN_CLOSED_STATE:
byte[0] = channel->id;
byte[1] = 0x00;
break;
case STK_CHANNEL_PACKET_DATA_SERVICE_ACTIVATED:
case STK_CHANNEL_TCP_IN_ESTABLISHED_STATE:
byte[0] = channel->id | 0x80;
byte[1] = 0x00;
break;
case STK_CHANNEL_TCP_IN_LISTEN_STATE:
byte[0] = channel->id | 0x40;
byte[1] = 0x00;
break;
case STK_CHANNEL_LINK_DROPPED:
byte[0] = channel->id;
byte[1] = 0x05;
break;
}
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, byte, 2) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.58 */
static bool build_dataobj_other_address(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_other_address *addr = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_OTHER_ADDRESS;
bool ok = false;
if (!addr->type)
return true;
if (!stk_tlv_builder_open_container(tlv, cr, tag, false))
return false;
switch (addr->type) {
case STK_ADDRESS_AUTO:
ok = true;
break;
case STK_ADDRESS_IPV4:
ok = stk_tlv_builder_append_byte(tlv, addr->type) &&
stk_tlv_builder_append_bytes(tlv,
(const uint8_t *) &addr->addr.ipv4, 4);
break;
case STK_ADDRESS_IPV6:
ok = stk_tlv_builder_append_byte(tlv, addr->type) &&
stk_tlv_builder_append_bytes(tlv, addr->addr.ipv6, 16);
break;
}
if (!ok)
return false;
return stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.59 */
static bool build_dataobj_uicc_te_interface(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_uicc_te_interface *iface = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_UICC_TE_INTERFACE;
if (iface->protocol == 0 && iface->port == 0)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, iface->protocol) &&
stk_tlv_builder_append_short(tlv, iface->port) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.61 */
static bool build_dataobj_access_technologies(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_access_technologies *techs = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_ACCESS_TECHNOLOGY;
int i;
if (!stk_tlv_builder_open_container(tlv, cr, tag, false))
return false;
for (i = 0; i < techs->length; i++)
if (!stk_tlv_builder_append_byte(tlv, techs->techs[i]))
return false;
return stk_tlv_builder_close_container(tlv);
}
/* Shortcut for a single Access Technology */
static bool build_dataobj_access_technology(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_access_technologies techs = {
.techs = data,
.length = 1,
};
return build_dataobj_access_technologies(tlv, &techs, cr);
}
/* Described in TS 102.223 Section 8.62 */
static bool build_dataobj_display_parameters(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_display_parameters *params = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_DISPLAY_PARAMETERS;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, params->height) &&
stk_tlv_builder_append_byte(tlv, params->width) &&
stk_tlv_builder_append_byte(tlv, params->effects) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.63 */
static bool build_dataobj_service_record(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_service_record *rec = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_SERVICE_RECORD;
return stk_tlv_builder_open_container(tlv, cr, tag, true) &&
stk_tlv_builder_append_byte(tlv, rec->tech_id) &&
stk_tlv_builder_append_byte(tlv, rec->serv_id) &&
stk_tlv_builder_append_bytes(tlv, rec->serv_rec, rec->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.68 */
static bool build_dataobj_remote_entity_address(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_remote_entity_address *addr = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_REMOTE_ENTITY_ADDRESS;
bool ok = false;
if (!addr->has_address)
return true;
if (!stk_tlv_builder_open_container(tlv, cr, tag, true))
return false;
if (!stk_tlv_builder_append_byte(tlv, addr->coding_type))
return false;
switch (addr->coding_type) {
case 0x00:
ok = stk_tlv_builder_append_bytes(tlv, addr->addr.ieee802, 6);
break;
case 0x01:
ok = stk_tlv_builder_append_bytes(tlv, addr->addr.irda, 4);
break;
}
if (!ok)
return false;
return stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.69 */
static bool build_dataobj_esn(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const uint32_t *esn = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_ESN;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_short(tlv, *esn >> 16) &&
stk_tlv_builder_append_short(tlv, *esn >> 0) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.72, 3GPP 24.008 Section 9.5.7 */
static bool build_dataobj_pdp_context_params(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_common_byte_array *params = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_PDP_ACTIVATION_PARAMETER;
if (params->len < 1)
return true;
if (params->len > 0x7f)
return false;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, params->array, params->len) &&
stk_tlv_builder_close_container(tlv);
}
/*
* Described in TS 102.223 Section 8.74
*
* See format note in parse_dataobj_imeisv.
*/
static bool build_dataobj_imeisv(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
char byte0[3];
const char *imeisv = data;
uint8_t value[9];
uint8_t tag = STK_DATA_OBJECT_TYPE_IMEISV;
if (imeisv == NULL)
return true;
if (strlen(imeisv) != 16)
return false;
byte0[0] = '3';
byte0[1] = imeisv[0];
byte0[2] = '\0';
sim_encode_bcd_number(byte0, value);
sim_encode_bcd_number(imeisv + 1, value + 1);
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, value, 9) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.75 */
static bool build_dataobj_network_search_mode(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const enum stk_network_search_mode *mode = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_NETWORK_SEARCH_MODE;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, *mode) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.76 */
static bool build_dataobj_battery_state(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const enum stk_battery_state *state = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_BATTERY_STATE;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, *state) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.77 */
static bool build_dataobj_browsing_status(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_common_byte_array *bs = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_BROWSING_STATUS;
return stk_tlv_builder_open_container(tlv, cr, tag, true) &&
stk_tlv_builder_append_bytes(tlv, bs->array, bs->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.79 */
static bool build_dataobj_frames_information(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_frames_info *info = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_FRAMES_INFO;
unsigned int i;
if (!stk_tlv_builder_open_container(tlv, cr, tag, false))
return false;
if (!stk_tlv_builder_append_byte(tlv, info->id))
return false;
for (i = 0; i < info->len; i++) {
if (!stk_tlv_builder_append_byte(tlv, info->list[i].height))
return false;
if (!stk_tlv_builder_append_byte(tlv, info->list[i].width))
return false;
}
return stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.81 */
static bool build_dataobj_meid(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const char *meid = data;
uint8_t value[8];
uint8_t tag = STK_DATA_OBJECT_TYPE_MEID;
if (meid == NULL)
return true;
if (strlen(meid) != 16)
return false;
sim_encode_bcd_number(meid, value);
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, value, 8) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.83 */
static bool build_dataobj_mms_id(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_mms_id *id = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_MMS_ID;
/* Assume the length is never 0 for a valid ID, however the whole
* data object's presence is conditional. */
if (id->len == 0)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, id->id, id->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.84 */
static bool build_dataobj_mms_transfer_status(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_mms_transfer_status *mts = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_MMS_TRANSFER_STATUS;
/*
* Assume the length is never 0 for a valid Result message, however
* the whole data object's presence is conditional.
*/
if (mts->len == 0)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, mts->status, mts->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.84 */
static bool build_dataobj_i_wlan_access_status(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const enum stk_i_wlan_access_status *status = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_I_WLAN_ACCESS_STATUS;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, *status) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.86 */
static bool build_dataobj_mms_notification(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_common_byte_array *msg = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_MMS_NOTIFICATION;
return stk_tlv_builder_open_container(tlv, cr, tag, true) &&
stk_tlv_builder_append_bytes(tlv, msg->array, msg->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.87 */
static bool build_dataobj_last_envelope(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const ofono_bool_t *last = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_LAST_ENVELOPE;
if (!*last)
return true;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.88 */
static bool build_dataobj_registry_application_data(
struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_registry_application_data *rad = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_REGISTRY_APPLICATION_DATA;
uint8_t dcs;
L_AUTO_FREE_VAR(uint8_t *, name);
size_t len;
long gsmlen;
name = convert_utf8_to_gsm(rad->name, -1, NULL, &gsmlen, 0);
len = gsmlen;
dcs = 0x04;
if (!name) {
name = l_utf8_to_ucs2be(rad->name, &len);
if (!name)
return false;
/* len includes null terminator, so strip it */
len -= 2;
dcs = 0x08;
}
return stk_tlv_builder_open_container(tlv, cr, tag, true) &&
stk_tlv_builder_append_short(tlv, rad->port) &&
stk_tlv_builder_append_byte(tlv, dcs) &&
stk_tlv_builder_append_byte(tlv, rad->type) &&
stk_tlv_builder_append_bytes(tlv, name, len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 102.223 Section 8.90 */
static bool build_dataobj_broadcast_network_information(
struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_broadcast_network_information *bni = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_BROADCAST_NETWORK_INFO;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, bni->tech) &&
stk_tlv_builder_append_bytes(tlv, bni->loc_info, bni->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.91 / 3GPP 24.008 Section 10.5.5.15 */
static bool build_dataobj_routing_area_id(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_routing_area_info *rai = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_ROUTING_AREA_INFO;
uint8_t mccmnc[3];
if (rai->mcc[0] == 0)
return true;
sim_encode_mcc_mnc(mccmnc, rai->mcc, rai->mnc);
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, mccmnc, 3) &&
stk_tlv_builder_append_short(tlv, rai->lac) &&
stk_tlv_builder_append_byte(tlv, rai->rac) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.92 */
static bool build_dataobj_update_attach_type(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const enum stk_update_attach_type *type = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_UPDATE_ATTACH_TYPE;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, *type) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.93 */
static bool build_dataobj_rejection_cause_code(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const enum stk_rejection_cause_code *cause = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_REJECTION_CAUSE_CODE;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, *cause) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.98, 3GPP 24.301 Section 6.5.1 */
static bool build_dataobj_eps_pdn_conn_params(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_common_byte_array *params = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_EPS_PDN_CONN_ACTIVATION_REQ;
if (params->len < 1)
return true;
if (params->len > 0x7f)
return false;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, params->array, params->len) &&
stk_tlv_builder_close_container(tlv);
}
/* Described in TS 131.111 Section 8.99 / 3GPP 24.301 Section 9.9.3.32 */
static bool build_dataobj_tracking_area_id(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_tracking_area_id *tai = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_TRACKING_AREA_ID;
uint8_t mccmnc[3];
if (tai->mcc[0] == 0)
return true;
sim_encode_mcc_mnc(mccmnc, tai->mcc, tai->mnc);
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_bytes(tlv, mccmnc, 3) &&
stk_tlv_builder_append_short(tlv, tai->tac) &&
stk_tlv_builder_close_container(tlv);
}
static bool build_dataobj(struct stk_tlv_builder *tlv,
dataobj_writer builder_func, ...)
{
va_list args;
va_start(args, builder_func);
while (builder_func) {
unsigned int flags = va_arg(args, enum stk_data_object_flag);
const void *data = va_arg(args, const void *);
bool cr = (flags & DATAOBJ_FLAG_CR) ? true : false;
if (!builder_func(tlv, data, cr))
return false;
builder_func = va_arg(args, dataobj_writer);
}
va_end(args);
return true;
}
static bool build_setup_call(struct stk_tlv_builder *builder,
const struct stk_response *response)
{
if (response->set_up_call.modified_result.cc_modified)
return build_dataobj(builder,
build_dataobj_cc_requested_action,
DATAOBJ_FLAG_CR,
&response->set_up_call.cc_requested_action,
build_dataobj_result,
DATAOBJ_FLAG_CR,
&response->set_up_call.modified_result.result,
NULL);
else
return build_dataobj(builder,
build_dataobj_cc_requested_action,
DATAOBJ_FLAG_CR,
&response->set_up_call.cc_requested_action,
NULL);
}
static bool build_local_info(struct stk_tlv_builder *builder,
const struct stk_response *response)
{
const struct stk_response_local_info *info =
&response->provide_local_info;
int i;
switch (response->qualifier) {
case 0x00: /* Location Information according to current NAA */
return build_dataobj(builder,
build_dataobj_location_info,
DATAOBJ_FLAG_CR, &info->location,
NULL);
case 0x01: /* IMEI of the terminal */
return build_dataobj(builder,
build_dataobj_imei,
DATAOBJ_FLAG_CR, info->imei,
NULL);
case 0x02: /* Network Measurement results according to current NAA */
return build_dataobj(builder,
build_dataobj_network_measurement_results,
DATAOBJ_FLAG_CR, &info->nmr.nmr,
build_dataobj_bcch_channel_list,
DATAOBJ_FLAG_CR, &info->nmr.bcch_ch_list,
NULL);
case 0x03: /* Date, time and time zone */
return build_dataobj(builder,
build_dataobj_datetime_timezone,
DATAOBJ_FLAG_CR, &info->datetime,
NULL);
case 0x04: /* Language setting */
return build_dataobj(builder,
build_dataobj_language,
DATAOBJ_FLAG_CR, info->language,
NULL);
case 0x05: /* Timing Advance */
return build_dataobj(builder,
build_dataobj_timing_advance,
DATAOBJ_FLAG_CR, &info->tadv,
NULL);
case 0x06: /* Access Technology (single access technology) */
return build_dataobj(builder,
build_dataobj_access_technology,
0, &info->access_technology,
NULL);
case 0x07: /* ESN of the terminal */
return build_dataobj(builder,
build_dataobj_esn,
DATAOBJ_FLAG_CR, &info->esn,
NULL);
case 0x08: /* IMEISV of the terminal */
return build_dataobj(builder,
build_dataobj_imeisv,
DATAOBJ_FLAG_CR, info->imeisv,
NULL);
case 0x09: /* Search Mode */
return build_dataobj(builder,
build_dataobj_network_search_mode,
0, &info->search_mode,
NULL);
case 0x0a: /* Charge State of the Battery */
return build_dataobj(builder,
build_dataobj_battery_state,
DATAOBJ_FLAG_CR, &info->battery_charge,
NULL);
case 0x0b: /* MEID of the terminal */
return build_dataobj(builder,
build_dataobj_meid,
0, info->meid,
NULL);
case 0x0d: /* Broadcast Network Information according to current tech */
return build_dataobj(builder,
build_dataobj_broadcast_network_information,
0, &info->broadcast_network_info,
NULL);
case 0x0e: /* Multiple Access Technologies */
return build_dataobj(builder,
build_dataobj_access_technologies,
0, &info->access_technologies,
NULL);
case 0x0f: /* Location Information for multiple NAAs */
if (!build_dataobj(builder,
build_dataobj_access_technologies,
0, &info->location_infos.access_techs,
NULL))
return false;
for (i = 0; i < info->location_infos.access_techs.length; i++) {
dataobj_writer location = build_dataobj_location_info;
/*
* "If no location information is available for an
* access technology, the respective data object
* shall have length zero."
*/
if (info->location_infos.locations[i].mcc[0] == '\0')
location = build_empty_dataobj_location_info;
if (!build_dataobj(builder,
location,
0, &info->location_infos.locations[i],
NULL))
return false;
}
return true;
case 0x10: /* Network Measurement results for multiple NAAs */
if (!build_dataobj(builder,
build_dataobj_access_technologies,
0, &info->nmrs.access_techs,
NULL))
return false;
for (i = 0; i < info->nmrs.access_techs.length; i++)
if (!build_dataobj(builder,
build_dataobj_network_measurement_results,
0, &info->nmrs.nmrs[i].nmr,
build_dataobj_bcch_channel_list,
0, &info->nmrs.nmrs[i].bcch_ch_list,
NULL))
return false;
return true;
}
return false;
}
static bool build_open_channel(struct stk_tlv_builder *builder,
const struct stk_response *response)
{
const struct stk_response_open_channel *open_channel =
&response->open_channel;
/* insert channel identifier only in case of success */
if (response->result.type == STK_RESULT_TYPE_SUCCESS) {
if (!build_dataobj(builder,
build_dataobj_channel_status,
0, &open_channel->channel,
NULL))
return false;
}
return build_dataobj(builder,
build_dataobj_bearer_description,
0, &open_channel->bearer_desc,
build_dataobj_buffer_size,
0, &open_channel->buf_size,
NULL);
}
static bool build_receive_data(struct stk_tlv_builder *builder,
const struct stk_response *response)
{
const struct stk_response_receive_data *receive_data =
&response->receive_data;
if (response->result.type != STK_RESULT_TYPE_SUCCESS &&
response->result.type != STK_RESULT_TYPE_MISSING_INFO)
return true;
if (receive_data->rx_data.len) {
if (!build_dataobj(builder,
build_dataobj_channel_data,
DATAOBJ_FLAG_CR,
&response->receive_data.rx_data,
NULL))
return false;
}
return build_dataobj(builder,
build_dataobj_channel_data_length,
DATAOBJ_FLAG_CR,
&response->receive_data.rx_remaining,
NULL);
}
static bool build_send_data(struct stk_tlv_builder *builder,
const struct stk_response *response)
{
if (response->result.type != STK_RESULT_TYPE_SUCCESS)
return true;
return build_dataobj(builder,
build_dataobj_channel_data_length,
DATAOBJ_FLAG_CR,
&response->send_data.tx_avail,
NULL);
}
const uint8_t *stk_pdu_from_response(const struct stk_response *response,
unsigned int *out_length)
{
struct stk_tlv_builder builder;
bool ok = true;
uint8_t tag;
static uint8_t pdu[512];
stk_tlv_builder_init(&builder, pdu, sizeof(pdu));
/*
* Encode command details, they come in order with
* Command Details TLV first, followed by Device Identities TLV
* and the Result TLV. Comprehension required everywhere.
*/
tag = STK_DATA_OBJECT_TYPE_COMMAND_DETAILS;
if (!stk_tlv_builder_open_container(&builder, true, tag, false))
return NULL;
if (!stk_tlv_builder_append_byte(&builder, response->number))
return NULL;
if (!stk_tlv_builder_append_byte(&builder, response->type))
return NULL;
if (!stk_tlv_builder_append_byte(&builder, response->qualifier))
return NULL;
if (!stk_tlv_builder_close_container(&builder))
return NULL;
/*
* TS 102 223 section 6.8 states:
* "For all COMPREHENSION-TLV objects with Min = N, the terminal
* should set the CR flag to comprehension not required."
* All the data objects except "Command Details" and "Result" have
* Min = N.
*
* However comprehension required is set for many of the TLVs in
* TS 102 384 conformance tests so we set it per command and per
* data object type.
*/
tag = STK_DATA_OBJECT_TYPE_DEVICE_IDENTITIES;
if (!stk_tlv_builder_open_container(&builder, true, tag, false))
return NULL;
if (!stk_tlv_builder_append_byte(&builder, response->src))
return NULL;
if (!stk_tlv_builder_append_byte(&builder, response->dst))
return NULL;
if (!stk_tlv_builder_close_container(&builder))
return NULL;
if (!build_dataobj_result(&builder, &response->result, true))
return NULL;
switch (response->type) {
case STK_COMMAND_TYPE_DISPLAY_TEXT:
break;
case STK_COMMAND_TYPE_GET_INKEY:
ok = build_dataobj(&builder,
build_dataobj_text, DATAOBJ_FLAG_CR,
&response->get_inkey.text,
build_dataobj_duration, 0,
&response->get_inkey.duration,
NULL);
break;
case STK_COMMAND_TYPE_GET_INPUT:
ok = build_dataobj(&builder,
build_dataobj_text, DATAOBJ_FLAG_CR,
&response->get_input.text,
NULL);
break;
case STK_COMMAND_TYPE_MORE_TIME:
case STK_COMMAND_TYPE_SEND_SMS:
case STK_COMMAND_TYPE_PLAY_TONE:
break;
case STK_COMMAND_TYPE_POLL_INTERVAL:
ok = build_dataobj(&builder,
build_dataobj_duration, DATAOBJ_FLAG_CR,
&response->poll_interval.max_interval,
NULL);
break;
case STK_COMMAND_TYPE_REFRESH:
case STK_COMMAND_TYPE_SETUP_MENU:
break;
case STK_COMMAND_TYPE_SELECT_ITEM:
ok = build_dataobj(&builder,
build_dataobj_item_id, DATAOBJ_FLAG_CR,
&response->select_item.item_id,
NULL);
break;
case STK_COMMAND_TYPE_SEND_SS:
break;
case STK_COMMAND_TYPE_SETUP_CALL:
ok = build_setup_call(&builder, response);
break;
case STK_COMMAND_TYPE_POLLING_OFF:
break;
case STK_COMMAND_TYPE_PROVIDE_LOCAL_INFO:
ok = build_local_info(&builder, response);
break;
case STK_COMMAND_TYPE_SETUP_EVENT_LIST:
break;
case STK_COMMAND_TYPE_TIMER_MANAGEMENT:
ok = build_dataobj(&builder,
build_dataobj_timer_id,
DATAOBJ_FLAG_CR,
&response->timer_mgmt.id,
build_dataobj_timer_value,
DATAOBJ_FLAG_CR,
&response->timer_mgmt.value,
NULL);
break;
case STK_COMMAND_TYPE_SETUP_IDLE_MODE_TEXT:
break;
case STK_COMMAND_TYPE_RUN_AT_COMMAND:
ok = build_dataobj(&builder,
build_dataobj_at_response,
DATAOBJ_FLAG_CR,
response->run_at_command.at_response,
NULL);
break;
case STK_COMMAND_TYPE_SEND_DTMF:
case STK_COMMAND_TYPE_LANGUAGE_NOTIFICATION:
case STK_COMMAND_TYPE_LAUNCH_BROWSER:
case STK_COMMAND_TYPE_CLOSE_CHANNEL:
break;
case STK_COMMAND_TYPE_SEND_USSD:
ok = build_dataobj(&builder,
build_dataobj_ussd_text,
DATAOBJ_FLAG_CR,
&response->send_ussd.text,
NULL);
break;
case STK_COMMAND_TYPE_OPEN_CHANNEL:
ok = build_open_channel(&builder, response);
break;
case STK_COMMAND_TYPE_RECEIVE_DATA:
ok = build_receive_data(&builder, response);
break;
case STK_COMMAND_TYPE_SEND_DATA:
ok = build_send_data(&builder, response);
break;
case STK_COMMAND_TYPE_GET_CHANNEL_STATUS:
ok = build_dataobj(&builder,
build_dataobj_channel_status,
DATAOBJ_FLAG_CR,
&response->channel_status.channel,
NULL);
break;
default:
return NULL;
};
if (!ok)
return NULL;
if (out_length)
*out_length = stk_tlv_builder_get_length(&builder);
return pdu;
}
/* Described in TS 102.223 Section 8.7 */
static bool build_envelope_dataobj_device_ids(struct stk_tlv_builder *tlv,
const void *data, bool cr)
{
const struct stk_envelope *envelope = data;
uint8_t tag = STK_DATA_OBJECT_TYPE_DEVICE_IDENTITIES;
return stk_tlv_builder_open_container(tlv, cr, tag, false) &&
stk_tlv_builder_append_byte(tlv, envelope->src) &&
stk_tlv_builder_append_byte(tlv, envelope->dst) &&
stk_tlv_builder_close_container(tlv);
}
static bool build_envelope_call_control(
struct stk_tlv_builder *builder,
const struct stk_envelope *envelope)
{
const struct stk_envelope_call_control *cc = &envelope->call_control;
bool ok = false;
if (!build_dataobj(builder,
build_envelope_dataobj_device_ids,
DATAOBJ_FLAG_CR, envelope, NULL))
return false;
switch (cc->type) {
case STK_CC_TYPE_CALL_SETUP:
ok = build_dataobj(builder,
build_dataobj_address,
DATAOBJ_FLAG_CR, &cc->address, NULL);
break;
case STK_CC_TYPE_SUPPLEMENTARY_SERVICE:
ok = build_dataobj(builder,
build_dataobj_ss_string,
DATAOBJ_FLAG_CR, &cc->ss_string, NULL);
break;
case STK_CC_TYPE_USSD_OP:
ok = build_dataobj(builder,
build_dataobj_ussd_string,
DATAOBJ_FLAG_CR, &cc->ussd_string,
NULL);
break;
case STK_CC_TYPE_PDP_CTX_ACTIVATION:
ok = build_dataobj(builder,
build_dataobj_pdp_context_params,
DATAOBJ_FLAG_CR, &cc->pdp_ctx_params,
NULL);
break;
case STK_CC_TYPE_EPS_PDN_CONNECTION_ACTIVATION:
ok = build_dataobj(builder,
build_dataobj_eps_pdn_conn_params,
DATAOBJ_FLAG_CR, &cc->eps_pdn_params,
NULL);
break;
}
if (!ok)
return false;
return build_dataobj(builder,
build_dataobj_ccp, 0, &cc->ccp1,
build_dataobj_subaddress, 0, &cc->subaddress,
build_dataobj_location_info, 0, &cc->location,
build_dataobj_ccp, 0, &cc->ccp2,
build_dataobj_alpha_id, 0, cc->alpha_id,
build_dataobj_bc_repeat, 0, &cc->bc_repeat,
NULL);
}
static bool build_envelope_event_download(struct stk_tlv_builder *builder,
const struct stk_envelope *envelope)
{
const struct stk_envelope_event_download *evt =
&envelope->event_download;
if (!build_dataobj(builder,
build_dataobj_event_type, DATAOBJ_FLAG_CR,
&evt->type,
build_envelope_dataobj_device_ids,
DATAOBJ_FLAG_CR,
envelope,
NULL))
return false;
switch (evt->type) {
case STK_EVENT_TYPE_MT_CALL:
return build_dataobj(builder,
build_dataobj_transaction_id,
DATAOBJ_FLAG_CR,
&evt->mt_call.transaction_id,
build_dataobj_address, 0,
&evt->mt_call.caller_address,
build_dataobj_subaddress, 0,
&evt->mt_call.caller_subaddress,
NULL);
case STK_EVENT_TYPE_CALL_CONNECTED:
return build_dataobj(builder,
build_dataobj_transaction_id,
DATAOBJ_FLAG_CR,
&evt->call_connected.transaction_id,
NULL);
case STK_EVENT_TYPE_CALL_DISCONNECTED:
return build_dataobj(builder,
build_dataobj_transaction_ids,
DATAOBJ_FLAG_CR,
&evt->call_disconnected.transaction_ids,
build_dataobj_cause, 0,
&evt->call_disconnected.cause,
NULL);
case STK_EVENT_TYPE_LOCATION_STATUS:
return build_dataobj(builder,
build_dataobj_location_status,
DATAOBJ_FLAG_CR,
&evt->location_status.state,
build_dataobj_location_info, 0,
&evt->location_status.info,
NULL);
case STK_EVENT_TYPE_USER_ACTIVITY:
case STK_EVENT_TYPE_IDLE_SCREEN_AVAILABLE:
return true;
case STK_EVENT_TYPE_CARD_READER_STATUS:
return build_dataobj(builder,
build_dataobj_card_reader_status,
DATAOBJ_FLAG_CR,
&evt->card_reader_status,
NULL);
case STK_EVENT_TYPE_LANGUAGE_SELECTION:
return build_dataobj(builder,
build_dataobj_language, DATAOBJ_FLAG_CR,
evt->language_selection,
NULL);
case STK_EVENT_TYPE_BROWSER_TERMINATION:
return build_dataobj(builder,
build_dataobj_browser_termination_cause,
DATAOBJ_FLAG_CR,
&evt->browser_termination.cause,
NULL);
case STK_EVENT_TYPE_DATA_AVAILABLE:
return build_dataobj(builder,
build_dataobj_channel_status,
DATAOBJ_FLAG_CR,
&evt->data_available.channel,
build_dataobj_channel_data_length,
DATAOBJ_FLAG_CR,
&evt->data_available.channel_data_len,
NULL);
case STK_EVENT_TYPE_CHANNEL_STATUS:
return build_dataobj(builder,
build_dataobj_channel_status,
DATAOBJ_FLAG_CR,
&evt->channel_status.channel,
build_dataobj_bearer_description,
DATAOBJ_FLAG_CR,
&evt->channel_status.bearer_desc,
build_dataobj_other_address,
DATAOBJ_FLAG_CR,
&evt->channel_status.address,
NULL);
case STK_EVENT_TYPE_SINGLE_ACCESS_TECHNOLOGY_CHANGE:
return build_dataobj(builder,
build_dataobj_access_technology,
DATAOBJ_FLAG_CR,
&evt->access_technology_change,
NULL);
case STK_EVENT_TYPE_DISPLAY_PARAMETERS_CHANGED:
return build_dataobj(builder,
build_dataobj_display_parameters,
DATAOBJ_FLAG_CR,
&evt->display_params_changed,
NULL);
case STK_EVENT_TYPE_LOCAL_CONNECTION:
return build_dataobj(builder,
build_dataobj_service_record,
DATAOBJ_FLAG_CR,
&evt->local_connection.service_record,
build_dataobj_remote_entity_address, 0,
&evt->local_connection.remote_addr,
build_dataobj_uicc_te_interface, 0,
&evt->local_connection.transport_level,
build_dataobj_other_address,
0,
&evt->local_connection.transport_addr,
NULL);
case STK_EVENT_TYPE_NETWORK_SEARCH_MODE_CHANGE:
return build_dataobj(builder,
build_dataobj_network_search_mode,
DATAOBJ_FLAG_CR,
&evt->network_search_mode_change,
NULL);
case STK_EVENT_TYPE_BROWSING_STATUS:
return build_dataobj(builder,
build_dataobj_browsing_status,
DATAOBJ_FLAG_CR,
&evt->browsing_status,
NULL);
case STK_EVENT_TYPE_FRAMES_INFORMATION_CHANGE:
return build_dataobj(builder,
build_dataobj_frames_information,
DATAOBJ_FLAG_CR,
&evt->frames_information_change,
NULL);
case STK_EVENT_TYPE_I_WLAN_ACCESS_STATUS:
return build_dataobj(builder,
build_dataobj_i_wlan_access_status,
DATAOBJ_FLAG_CR,
&evt->i_wlan_access_status,
NULL);
case STK_EVENT_TYPE_NETWORK_REJECTION:
return build_dataobj(builder,
build_dataobj_location_info, 0,
&evt->network_rejection.location,
build_dataobj_routing_area_id, 0,
&evt->network_rejection.rai,
build_dataobj_tracking_area_id, 0,
&evt->network_rejection.tai,
build_dataobj_access_technology,
DATAOBJ_FLAG_CR,
&evt->network_rejection.access_tech,
build_dataobj_update_attach_type,
DATAOBJ_FLAG_CR,
&evt->network_rejection.update_attach,
build_dataobj_rejection_cause_code,
DATAOBJ_FLAG_CR,
&evt->network_rejection.cause,
NULL);
case STK_EVENT_TYPE_HCI_CONNECTIVITY_EVENT:
return true;
default:
return false;
}
}
static bool build_envelope_terminal_apps(struct stk_tlv_builder *builder,
const struct stk_envelope *envelope)
{
const struct stk_envelope_terminal_apps *ta = &envelope->terminal_apps;
int i;
if (!build_dataobj(builder,
build_envelope_dataobj_device_ids,
DATAOBJ_FLAG_CR, envelope, NULL))
return false;
for (i = 0; i < ta->count; i++)
if (!build_dataobj(builder,
build_dataobj_registry_application_data,
0, &ta->list[i], NULL))
return false;
return build_dataobj(builder,
build_dataobj_last_envelope,
0, &ta->last, NULL);
}
const uint8_t *stk_pdu_from_envelope(const struct stk_envelope *envelope,
unsigned int *out_length)
{
struct ber_tlv_builder btlv;
struct stk_tlv_builder builder;
bool ok = true;
static uint8_t buffer[512];
uint8_t *pdu;
if (ber_tlv_builder_init(&btlv, buffer, sizeof(buffer)) != TRUE)
return NULL;
if (!stk_tlv_builder_recurse(&builder, &btlv, envelope->type))
return NULL;
switch (envelope->type) {
case STK_ENVELOPE_TYPE_SMS_PP_DOWNLOAD:
ok = build_dataobj(&builder,
build_envelope_dataobj_device_ids,
DATAOBJ_FLAG_CR,
envelope,
build_dataobj_address, 0,
&envelope->sms_pp_download.address,
build_dataobj_gsm_sms_tpdu,
DATAOBJ_FLAG_CR,
&envelope->sms_pp_download.message,
NULL);
break;
case STK_ENVELOPE_TYPE_CBS_PP_DOWNLOAD:
ok = build_dataobj(&builder,
build_envelope_dataobj_device_ids,
DATAOBJ_FLAG_CR,
envelope,
build_dataobj_cbs_page,
DATAOBJ_FLAG_CR,
&envelope->cbs_pp_download.page,
NULL);
break;
case STK_ENVELOPE_TYPE_MENU_SELECTION:
ok = build_dataobj(&builder,
build_envelope_dataobj_device_ids,
DATAOBJ_FLAG_CR,
envelope,
build_dataobj_item_id, DATAOBJ_FLAG_CR,
&envelope->menu_selection.item_id,
build_dataobj_help_request, 0,
&envelope->menu_selection.help_request,
NULL);
break;
case STK_ENVELOPE_TYPE_CALL_CONTROL:
ok = build_envelope_call_control(&builder, envelope);
break;
case STK_ENVELOPE_TYPE_MO_SMS_CONTROL:
/*
* Comprehension Required according to the specs but not
* enabled in conformance tests in 3GPP 31.124.
*/
ok = build_dataobj(&builder,
build_envelope_dataobj_device_ids, 0,
envelope,
build_dataobj_address, 0,
&envelope->sms_mo_control.sc_address,
build_dataobj_address, 0,
&envelope->sms_mo_control.dest_address,
build_dataobj_location_info, 0,
&envelope->sms_mo_control.location,
NULL);
break;
case STK_ENVELOPE_TYPE_EVENT_DOWNLOAD:
ok = build_envelope_event_download(&builder, envelope);
break;
case STK_ENVELOPE_TYPE_TIMER_EXPIRATION:
ok = build_dataobj(&builder,
build_envelope_dataobj_device_ids,
DATAOBJ_FLAG_CR,
envelope,
build_dataobj_timer_id,
DATAOBJ_FLAG_CR,
&envelope->timer_expiration.id,
build_dataobj_timer_value,
DATAOBJ_FLAG_CR,
&envelope->timer_expiration.value,
NULL);
break;
case STK_ENVELOPE_TYPE_USSD_DOWNLOAD:
ok = build_dataobj(&builder,
build_envelope_dataobj_device_ids,
DATAOBJ_FLAG_CR,
envelope,
build_dataobj_ussd_string,
DATAOBJ_FLAG_CR,
&envelope->ussd_data_download.string,
NULL);
break;
case STK_ENVELOPE_TYPE_MMS_TRANSFER_STATUS:
ok = build_dataobj(&builder,
build_envelope_dataobj_device_ids,
DATAOBJ_FLAG_CR,
envelope,
build_dataobj_file, DATAOBJ_FLAG_CR,
&envelope->mms_status.transfer_file,
build_dataobj_mms_id, 0,
&envelope->mms_status.id,
build_dataobj_mms_transfer_status, 0,
&envelope->mms_status.transfer_status,
NULL);
break;
case STK_ENVELOPE_TYPE_MMS_NOTIFICATION:
ok = build_dataobj(&builder,
build_envelope_dataobj_device_ids,
DATAOBJ_FLAG_CR,
envelope,
build_dataobj_mms_notification,
DATAOBJ_FLAG_CR,
&envelope->mms_notification.msg,
build_dataobj_last_envelope, 0,
&envelope->mms_notification.last,
NULL);
break;
case STK_ENVELOPE_TYPE_TERMINAL_APP:
ok = build_envelope_terminal_apps(&builder, envelope);
break;
default:
return NULL;
};
if (!ok)
return NULL;
ber_tlv_builder_optimize(&btlv, &pdu, out_length);
return pdu;
}
static const char *html_colors[] = {
"#000000", /* Black */
"#808080", /* Dark Grey */
"#C11B17", /* Dark Red */
"#FBB117", /* Dark Yellow */
"#347235", /* Dark Green */
"#307D7E", /* Dark Cyan */
"#0000A0", /* Dark Blue */
"#C031C7", /* Dark Magenta */
"#C0C0C0", /* Grey */
"#FFFFFF", /* White */
"#FF0000", /* Bright Red */
"#FFFF00", /* Bright Yellow */
"#00FF00", /* Bright Green */
"#00FFFF", /* Bright Cyan */
"#0000FF", /* Bright Blue */
"#FF00FF", /* Bright Magenta */
};
#define STK_TEXT_FORMAT_ALIGN_MASK 0x03
#define STK_TEXT_FORMAT_FONT_MASK 0x0C
#define STK_TEXT_FORMAT_STYLE_MASK 0xF0
#define STK_DEFAULT_TEXT_ALIGNMENT 0x00
#define STK_TEXT_FORMAT_INIT 0x9003
/* Defined in ETSI 123 40 9.2.3.24.10.1.1 */
enum stk_text_format_code {
STK_TEXT_FORMAT_LEFT_ALIGN = 0x00,
STK_TEXT_FORMAT_CENTER_ALIGN = 0x01,
STK_TEXT_FORMAT_RIGHT_ALIGN = 0x02,
STK_TEXT_FORMAT_NO_ALIGN = 0x03,
STK_TEXT_FORMAT_FONT_SIZE_LARGE = 0x04,
STK_TEXT_FORMAT_FONT_SIZE_SMALL = 0x08,
STK_TEXT_FORMAT_FONT_SIZE_RESERVED = 0x0c,
STK_TEXT_FORMAT_STYLE_BOLD = 0x10,
STK_TEXT_FORMAT_STYLE_ITALIC = 0x20,
STK_TEXT_FORMAT_STYLE_UNDERLINED = 0x40,
STK_TEXT_FORMAT_STYLE_STRIKETHROUGH = 0x80,
};
static void end_format(struct l_string *string, uint16_t attr)
{
uint8_t code = attr & 0xFF;
uint8_t color = (attr >> 8) & 0xFF;
if ((code & ~STK_TEXT_FORMAT_ALIGN_MASK) || color)
l_string_append(string, "</span>");
if ((code & STK_TEXT_FORMAT_ALIGN_MASK) != STK_TEXT_FORMAT_NO_ALIGN)
l_string_append(string, "</div>");
}
static void start_format(struct l_string *string, uint16_t attr)
{
uint8_t code = attr & 0xFF;
uint8_t color = (attr >> 8) & 0xFF;
uint8_t align = code & STK_TEXT_FORMAT_ALIGN_MASK;
uint8_t font = code & STK_TEXT_FORMAT_FONT_MASK;
uint8_t style = code & STK_TEXT_FORMAT_STYLE_MASK;
int fg = color & 0x0f;
int bg = (color >> 4) & 0x0f;
/* align formatting applies to a block of text */
if (align != STK_TEXT_FORMAT_NO_ALIGN)
l_string_append(string, "<div style=\"");
switch (align) {
case STK_TEXT_FORMAT_RIGHT_ALIGN:
l_string_append(string, "text-align: right;\">");
break;
case STK_TEXT_FORMAT_CENTER_ALIGN:
l_string_append(string, "text-align: center;\">");
break;
case STK_TEXT_FORMAT_LEFT_ALIGN:
l_string_append(string, "text-align: left;\">");
break;
}
if ((font == 0) && (style == 0) && (color == 0))
return;
/* font, style, and color are inline */
l_string_append(string, "<span style=\"");
switch (font) {
case STK_TEXT_FORMAT_FONT_SIZE_LARGE:
l_string_append(string, "font-size: big;");
break;
case STK_TEXT_FORMAT_FONT_SIZE_SMALL:
l_string_append(string, "font-size: small;");
break;
}
if (style & STK_TEXT_FORMAT_STYLE_BOLD)
l_string_append(string, "font-weight: bold;");
if (style & STK_TEXT_FORMAT_STYLE_ITALIC)
l_string_append(string, "font-style: italic;");
if (style & STK_TEXT_FORMAT_STYLE_UNDERLINED)
l_string_append(string, "text-decoration: underline;");
if (style & STK_TEXT_FORMAT_STYLE_STRIKETHROUGH)
l_string_append(string, "text-decoration: line-through;");
/* add any color */
l_string_append_printf(string, "color: %s;", html_colors[fg]);
l_string_append_printf(string, "background-color: %s;",
html_colors[bg]);
l_string_append(string, "\">");
}
char *stk_text_to_html(const char *utf8,
const uint16_t *attrs, int num_attrs)
{
long text_len = l_utf8_strlen(utf8);
struct l_string *string = l_string_new(strlen(utf8) + 1);
short *formats;
int pos, i, j;
uint16_t start, end, len, attr, prev_attr;
uint8_t code, color, align;
const char *text = utf8;
int attrs_len = num_attrs * 4;
formats = l_new(int16_t, text_len + 1);
/* we will need formatting at the position beyond the last char */
for (i = 0; i <= text_len; i++)
formats[i] = STK_TEXT_FORMAT_INIT;
for (i = 0; i < attrs_len; i += 4) {
start = attrs[i];
len = attrs[i + 1];
code = attrs[i + 2] & 0xFF;
color = attrs[i + 3] & 0xFF;
if (len == 0)
end = text_len;
else
end = start + len;
/* sanity check values */
if (start > end || end > text_len)
continue;
/*
* if the alignment is the same as either the default
* or the last alignment used, don't set any alignment
* value.
*/
if (start == 0)
align = STK_TEXT_FORMAT_NO_ALIGN;
else {
align = formats[start - 1] &
STK_TEXT_FORMAT_ALIGN_MASK;
}
if ((code & STK_TEXT_FORMAT_ALIGN_MASK) == align)
code |= STK_TEXT_FORMAT_NO_ALIGN;
attr = code | (color << 8);
for (j = start; j < end; j++)
formats[j] = attr;
}
prev_attr = STK_TEXT_FORMAT_INIT;
for (pos = 0; pos <= text_len; pos++) {
wchar_t c;
int len;
attr = formats[pos];
if (attr != prev_attr) {
if (prev_attr != STK_TEXT_FORMAT_INIT)
end_format(string, prev_attr);
if (attr != STK_TEXT_FORMAT_INIT)
start_format(string, attr);
prev_attr = attr;
}
if (pos == text_len)
break;
len = l_utf8_get_codepoint(text, 4, &c);
switch (c) {
case '\n':
l_string_append(string, "<br/>");
break;
case '\r':
/* If the next character is a newline, consume it */
if ((pos + 1 < text_len) && (text[len] == '\n')) {
pos += 1;
len += 1;
}
l_string_append(string, "<br/>");
break;
case '<':
l_string_append(string, "&lt;");
break;
case '>':
l_string_append(string, "&gt;");
break;
case '&':
l_string_append(string, "&amp;");
break;
default:
l_string_append_fixed(string, text, len);
}
text += len;
}
l_free(formats);
/* return characters from string. Caller must free char data */
return l_string_unwrap(string);
}
static const char chars_table[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c',
'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '+', '.' };
char *stk_image_to_xpm(const uint8_t *img, unsigned int len,
enum stk_img_scheme scheme, const uint8_t *clut,
uint16_t clut_len)
{
uint8_t width, height;
unsigned int ncolors, nbits, entry, cpp;
unsigned int i, j;
int bit, k;
struct l_string *xpm;
unsigned int pos = 0;
const char xpm_header[] = "/* XPM */\n";
const char declaration[] = "static char *xpm[] = {\n";
char c[3];
if (img == NULL)
return NULL;
/* sanity check length */
if (len < 3)
return NULL;
width = img[pos++];
height = img[pos++];
if (scheme == STK_IMG_SCHEME_BASIC) {
nbits = 1;
ncolors = 2;
} else {
/* sanity check length */
if ((pos + 4 > len) || (clut == NULL))
return NULL;
nbits = img[pos++];
ncolors = img[pos++];
/* the value of zero should be interpreted as 256 */
if (ncolors == 0)
ncolors = 256;
/* skip clut offset bytes */
pos += 2;
if ((ncolors * 3) > clut_len)
return NULL;
}
if (pos + ((width * height + 7) / 8) > len)
return NULL;
/* determine the number of chars need to represent the pixel */
cpp = ncolors > 64 ? 2 : 1;
/*
* space needed:
* header line
* declaration and beginning of assignment line
* values - max length of 19
* colors - ncolors * (cpp + whitespace + deliminators + color)
* pixels - width * height * cpp + height deliminators "",\n
* end of assignment - 2 chars "};"
*/
xpm = l_string_new(strlen(xpm_header) + strlen(declaration) +
19 + ((cpp + 14) * ncolors) +
(width * height * cpp) + (4 * height) + 2);
/* add header, declaration, values */
l_string_append(xpm, xpm_header);
l_string_append(xpm, declaration);
l_string_append_printf(xpm, "\"%d %d %d %d\",\n", width, height,
ncolors, cpp);
/* create colors */
if (scheme == STK_IMG_SCHEME_BASIC) {
l_string_append(xpm, "\"0\tc #000000\",\n");
l_string_append(xpm, "\"1\tc #FFFFFF\",\n");
} else {
for (i = 0; i < ncolors; i++) {
/* lookup char representation of this number */
if (ncolors > 64) {
c[0] = chars_table[i / 64];
c[1] = chars_table[i % 64];
c[2] = '\0';
} else {
c[0] = chars_table[i % 64];
c[1] = '\0';
}
if ((i == (ncolors - 1)) &&
scheme == STK_IMG_SCHEME_TRANSPARENCY)
l_string_append_printf(xpm,
"\"%s\tc None\",\n", c);
else
l_string_append_printf(xpm,
"\"%s\tc #%02hhX%02hhX%02hhX\",\n",
c, clut[0], clut[1], clut[2]);
clut += 3;
}
}
/* height rows of width pixels */
k = 7;
for (i = 0; i < height; i++) {
l_string_append(xpm, "\"");
for (j = 0; j < width; j++) {
entry = 0;
for (bit = nbits - 1; bit >= 0; bit--) {
entry |= (img[pos] >> k & 0x1) << bit;
k--;
/* see if we crossed a byte boundary */
if (k < 0) {
k = 7;
pos++;
}
}
/* lookup char representation of this number */
if (ncolors > 64) {
c[0] = chars_table[entry / 64];
c[1] = chars_table[entry % 64];
c[2] = '\0';
} else {
c[0] = chars_table[entry % 64];
c[1] = '\0';
}
l_string_append_printf(xpm, "%s", c);
}
l_string_append(xpm, "\",\n");
}
l_string_append(xpm, "};");
/* Caller must free char data */
return l_string_unwrap(xpm);
}
You can’t perform that action at this time.