2010-02-17 21:10:33 +00:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* oFono - Open Source Telephony
|
|
|
|
*
|
2011-10-10 20:39:42 +00:00
|
|
|
* Copyright (C) 2008-2011 Intel Corporation. All rights reserved.
|
2010-02-17 21:10:33 +00:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2018-12-28 19:48:34 +00:00
|
|
|
struct l_queue;
|
|
|
|
|
2010-02-18 00:22:18 +00:00
|
|
|
/*
|
|
|
|
* TS 101.220, Section 7.2, Card Application Toolkit assigned templates,
|
2011-02-02 08:55:14 +00:00
|
|
|
* These are the same as 3GPP 11.14 Sections 13.1 and 13.2
|
2010-02-18 00:22:18 +00:00
|
|
|
*/
|
|
|
|
enum stk_envelope_type {
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_ENVELOPE_TYPE_SMS_PP_DOWNLOAD = 0xD1,
|
|
|
|
STK_ENVELOPE_TYPE_CBS_PP_DOWNLOAD = 0xD2,
|
|
|
|
STK_ENVELOPE_TYPE_MENU_SELECTION = 0xD3,
|
|
|
|
STK_ENVELOPE_TYPE_CALL_CONTROL = 0xD4,
|
|
|
|
STK_ENVELOPE_TYPE_MO_SMS_CONTROL = 0xD5,
|
|
|
|
STK_ENVELOPE_TYPE_EVENT_DOWNLOAD = 0xD6,
|
|
|
|
STK_ENVELOPE_TYPE_TIMER_EXPIRATION = 0xD7,
|
|
|
|
STK_ENVELOPE_TYPE_USSD_DOWNLOAD = 0xD9,
|
2010-06-11 10:39:55 +00:00
|
|
|
STK_ENVELOPE_TYPE_MMS_TRANSFER_STATUS = 0xDA,
|
|
|
|
STK_ENVELOPE_TYPE_MMS_NOTIFICATION = 0xDB,
|
|
|
|
STK_ENVELOPE_TYPE_TERMINAL_APP = 0xDC,
|
|
|
|
STK_ENVELOPE_TYPE_GEOLOCATION_REPORT = 0xDD,
|
2010-02-18 00:22:18 +00:00
|
|
|
};
|
|
|
|
|
2010-02-18 00:22:04 +00:00
|
|
|
/* TS 102.223 Section 9.4 */
|
|
|
|
enum stk_command_type {
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_COMMAND_TYPE_REFRESH = 0x01,
|
2010-03-24 09:35:43 +00:00
|
|
|
STK_COMMAND_TYPE_MORE_TIME = 0x02,
|
|
|
|
STK_COMMAND_TYPE_POLL_INTERVAL = 0x03,
|
|
|
|
STK_COMMAND_TYPE_POLLING_OFF = 0x04,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_COMMAND_TYPE_SETUP_EVENT_LIST = 0x05,
|
|
|
|
STK_COMMAND_TYPE_SETUP_CALL = 0x10,
|
|
|
|
STK_COMMAND_TYPE_SEND_SS = 0x11,
|
|
|
|
STK_COMMAND_TYPE_SEND_USSD = 0x12,
|
|
|
|
STK_COMMAND_TYPE_SEND_SMS = 0x13,
|
|
|
|
STK_COMMAND_TYPE_SEND_DTMF = 0x14,
|
|
|
|
STK_COMMAND_TYPE_LAUNCH_BROWSER = 0x15,
|
|
|
|
STK_COMMAND_TYPE_GEOGRAPICAL_LOCATION_REQUEST = 0x16,
|
|
|
|
STK_COMMAND_TYPE_PLAY_TONE = 0x20,
|
|
|
|
STK_COMMAND_TYPE_DISPLAY_TEXT = 0x21,
|
|
|
|
STK_COMMAND_TYPE_GET_INKEY = 0x22,
|
|
|
|
STK_COMMAND_TYPE_GET_INPUT = 0x23,
|
|
|
|
STK_COMMAND_TYPE_SELECT_ITEM = 0x24,
|
|
|
|
STK_COMMAND_TYPE_SETUP_MENU = 0x25,
|
2010-03-25 16:07:30 +00:00
|
|
|
STK_COMMAND_TYPE_PROVIDE_LOCAL_INFO = 0x26,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_COMMAND_TYPE_TIMER_MANAGEMENT = 0x27,
|
|
|
|
STK_COMMAND_TYPE_SETUP_IDLE_MODE_TEXT = 0x28,
|
|
|
|
STK_COMMAND_TYPE_PERFORM_CARD_APDU = 0x30,
|
|
|
|
STK_COMMAND_TYPE_POWER_ON_CARD = 0x31,
|
|
|
|
STK_COMMAND_TYPE_POWER_OFF_CARD = 0x32,
|
|
|
|
STK_COMMAND_TYPE_GET_READER_STATUS = 0x33,
|
|
|
|
STK_COMMAND_TYPE_RUN_AT_COMMAND = 0x34,
|
|
|
|
STK_COMMAND_TYPE_LANGUAGE_NOTIFICATION = 0x35,
|
|
|
|
STK_COMMAND_TYPE_OPEN_CHANNEL = 0x40,
|
|
|
|
STK_COMMAND_TYPE_CLOSE_CHANNEL = 0x41,
|
|
|
|
STK_COMMAND_TYPE_RECEIVE_DATA = 0x42,
|
|
|
|
STK_COMMAND_TYPE_SEND_DATA = 0x43,
|
|
|
|
STK_COMMAND_TYPE_GET_CHANNEL_STATUS = 0x44,
|
|
|
|
STK_COMMAND_TYPE_SERVICE_SEARCH = 0x45,
|
2010-03-25 16:07:30 +00:00
|
|
|
STK_COMMAND_TYPE_GET_SERVICE_INFO = 0x46,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_COMMAND_TYPE_DECLARE_SERVICE = 0x47,
|
|
|
|
STK_COMMAND_TYPE_SET_FRAMES = 0x50,
|
|
|
|
STK_COMMAND_TYPE_GET_FRAMES_STATUS = 0x51,
|
|
|
|
STK_COMMAND_TYPE_RETRIEVE_MMS = 0x60,
|
|
|
|
STK_COMMAND_TYPE_SUBMIT_MMS = 0x61,
|
|
|
|
STK_COMMAND_TYPE_DISPLAY_MMS = 0x62,
|
|
|
|
STK_COMMAND_TYPE_ACTIVATE = 0x70,
|
|
|
|
STK_COMMAND_TYPE_END_SESSION = 0x81,
|
2010-02-18 00:22:04 +00:00
|
|
|
};
|
2010-02-18 16:58:22 +00:00
|
|
|
|
|
|
|
enum stk_data_object_type {
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_INVALID = 0x00,
|
|
|
|
STK_DATA_OBJECT_TYPE_COMMAND_DETAILS = 0x01,
|
|
|
|
STK_DATA_OBJECT_TYPE_DEVICE_IDENTITIES = 0x02,
|
|
|
|
STK_DATA_OBJECT_TYPE_RESULT = 0x03,
|
|
|
|
STK_DATA_OBJECT_TYPE_DURATION = 0x04,
|
|
|
|
STK_DATA_OBJECT_TYPE_ALPHA_ID = 0x05,
|
|
|
|
STK_DATA_OBJECT_TYPE_ADDRESS = 0x06,
|
|
|
|
STK_DATA_OBJECT_TYPE_CCP = 0x07,
|
|
|
|
STK_DATA_OBJECT_TYPE_SUBADDRESS = 0x08,
|
|
|
|
STK_DATA_OBJECT_TYPE_SS_STRING = 0x09,
|
|
|
|
STK_DATA_OBJECT_TYPE_USSD_STRING = 0x0A,
|
|
|
|
STK_DATA_OBJECT_TYPE_GSM_SMS_TPDU = 0x0B,
|
|
|
|
STK_DATA_OBJECT_TYPE_CBS_PAGE = 0x0C,
|
|
|
|
STK_DATA_OBJECT_TYPE_TEXT = 0x0D,
|
|
|
|
STK_DATA_OBJECT_TYPE_TONE = 0x0E,
|
|
|
|
STK_DATA_OBJECT_TYPE_ITEM = 0x0F,
|
|
|
|
STK_DATA_OBJECT_TYPE_ITEM_ID = 0x10,
|
|
|
|
STK_DATA_OBJECT_TYPE_RESPONSE_LENGTH = 0x11,
|
|
|
|
STK_DATA_OBJECT_TYPE_FILE_LIST = 0x12,
|
|
|
|
STK_DATA_OBJECT_TYPE_LOCATION_INFO = 0x13,
|
|
|
|
STK_DATA_OBJECT_TYPE_IMEI = 0x14,
|
|
|
|
STK_DATA_OBJECT_TYPE_HELP_REQUEST = 0x15,
|
|
|
|
STK_DATA_OBJECT_TYPE_NETWORK_MEASUREMENT_RESULTS = 0x16,
|
|
|
|
STK_DATA_OBJECT_TYPE_DEFAULT_TEXT = 0x17,
|
|
|
|
STK_DATA_OBJECT_TYPE_ITEMS_NEXT_ACTION_INDICATOR = 0x18,
|
|
|
|
STK_DATA_OBJECT_TYPE_EVENT_LIST = 0x19,
|
|
|
|
STK_DATA_OBJECT_TYPE_CAUSE = 0x1A,
|
|
|
|
STK_DATA_OBJECT_TYPE_LOCATION_STATUS = 0x1B,
|
|
|
|
STK_DATA_OBJECT_TYPE_TRANSACTION_ID = 0x1C,
|
2010-05-27 04:59:44 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_BCCH_CHANNEL_LIST = 0x1D,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_ICON_ID = 0x1E,
|
|
|
|
STK_DATA_OBJECT_TYPE_ITEM_ICON_ID_LIST = 0x1F,
|
|
|
|
STK_DATA_OBJECT_TYPE_CARD_READER_STATUS = 0x20,
|
|
|
|
STK_DATA_OBJECT_TYPE_CARD_ATR = 0x21,
|
|
|
|
STK_DATA_OBJECT_TYPE_C_APDU = 0x22,
|
|
|
|
STK_DATA_OBJECT_TYPE_R_APDU = 0x23,
|
|
|
|
STK_DATA_OBJECT_TYPE_TIMER_ID = 0x24,
|
|
|
|
STK_DATA_OBJECT_TYPE_TIMER_VALUE = 0x25,
|
|
|
|
STK_DATA_OBJECT_TYPE_DATETIME_TIMEZONE = 0x26,
|
|
|
|
STK_DATA_OBJECT_TYPE_CALL_CONTROL_REQUESTED_ACTION = 0x27,
|
|
|
|
STK_DATA_OBJECT_TYPE_AT_COMMAND = 0x28,
|
|
|
|
STK_DATA_OBJECT_TYPE_AT_RESPONSE = 0x29,
|
|
|
|
STK_DATA_OBJECT_TYPE_BC_REPEAT_INDICATOR = 0x2A,
|
|
|
|
STK_DATA_OBJECT_TYPE_IMMEDIATE_RESPONSE = 0x2B,
|
|
|
|
STK_DATA_OBJECT_TYPE_DTMF_STRING = 0x2C,
|
|
|
|
STK_DATA_OBJECT_TYPE_LANGUAGE = 0x2D,
|
|
|
|
STK_DATA_OBJECT_TYPE_TIMING_ADVANCE = 0x2E,
|
|
|
|
STK_DATA_OBJECT_TYPE_AID = 0x2F,
|
|
|
|
STK_DATA_OBJECT_TYPE_BROWSER_ID = 0x30,
|
|
|
|
STK_DATA_OBJECT_TYPE_URL = 0x31,
|
|
|
|
STK_DATA_OBJECT_TYPE_BEARER = 0x32,
|
2010-05-27 17:36:47 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_PROVISIONING_FILE_REF = 0x33,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_BROWSER_TERMINATION_CAUSE = 0x34,
|
|
|
|
STK_DATA_OBJECT_TYPE_BEARER_DESCRIPTION = 0x35,
|
|
|
|
STK_DATA_OBJECT_TYPE_CHANNEL_DATA = 0x36,
|
|
|
|
STK_DATA_OBJECT_TYPE_CHANNEL_DATA_LENGTH = 0x37,
|
|
|
|
STK_DATA_OBJECT_TYPE_CHANNEL_STATUS = 0x38,
|
|
|
|
STK_DATA_OBJECT_TYPE_BUFFER_SIZE = 0x39,
|
|
|
|
STK_DATA_OBJECT_TYPE_CARD_READER_ID = 0x3A,
|
|
|
|
STK_DATA_OBJECT_TYPE_FILE_UPDATE_INFO = 0x3B,
|
|
|
|
STK_DATA_OBJECT_TYPE_UICC_TE_INTERFACE = 0x3C,
|
|
|
|
STK_DATA_OBJECT_TYPE_OTHER_ADDRESS = 0x3E,
|
|
|
|
STK_DATA_OBJECT_TYPE_ACCESS_TECHNOLOGY = 0x3F,
|
|
|
|
STK_DATA_OBJECT_TYPE_DISPLAY_PARAMETERS = 0x40,
|
|
|
|
STK_DATA_OBJECT_TYPE_SERVICE_RECORD = 0x41,
|
|
|
|
STK_DATA_OBJECT_TYPE_DEVICE_FILTER = 0x42,
|
|
|
|
STK_DATA_OBJECT_TYPE_SERVICE_SEARCH = 0x43,
|
|
|
|
STK_DATA_OBJECT_TYPE_ATTRIBUTE_INFO = 0x44,
|
|
|
|
STK_DATA_OBJECT_TYPE_SERVICE_AVAILABILITY = 0x45,
|
|
|
|
STK_DATA_OBJECT_TYPE_ESN = 0x46,
|
|
|
|
STK_DATA_OBJECT_TYPE_NETWORK_ACCESS_NAME = 0x47,
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_CDMA_SMS_TPDU = 0x48,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_REMOTE_ENTITY_ADDRESS = 0x49,
|
2010-06-11 10:39:50 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_I_WLAN_ID_TAG = 0x4A,
|
|
|
|
STK_DATA_OBJECT_TYPE_I_WLAN_ACCESS_STATUS = 0x4B,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_TEXT_ATTRIBUTE = 0x50,
|
|
|
|
STK_DATA_OBJECT_TYPE_ITEM_TEXT_ATTRIBUTE_LIST = 0x51,
|
|
|
|
STK_DATA_OBJECT_TYPE_PDP_ACTIVATION_PARAMETER = 0x52,
|
|
|
|
STK_DATA_OBJECT_TYPE_IMEISV = 0x62,
|
|
|
|
STK_DATA_OBJECT_TYPE_BATTERY_STATE = 0x63,
|
|
|
|
STK_DATA_OBJECT_TYPE_BROWSING_STATUS = 0x64,
|
|
|
|
STK_DATA_OBJECT_TYPE_NETWORK_SEARCH_MODE = 0x65,
|
|
|
|
STK_DATA_OBJECT_TYPE_FRAME_LAYOUT = 0x66,
|
|
|
|
STK_DATA_OBJECT_TYPE_FRAMES_INFO = 0x67,
|
|
|
|
STK_DATA_OBJECT_TYPE_FRAME_ID = 0x68,
|
2010-06-13 09:43:22 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_UTRAN_MEASUREMENT_QUALIFIER = 0x69,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_MMS_REFERENCE = 0x6A,
|
|
|
|
STK_DATA_OBJECT_TYPE_MMS_ID = 0x6B,
|
|
|
|
STK_DATA_OBJECT_TYPE_MMS_TRANSFER_STATUS = 0x6C,
|
|
|
|
STK_DATA_OBJECT_TYPE_MEID = 0x6D,
|
2010-03-25 16:07:30 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_MMS_CONTENT_ID = 0x6E,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_MMS_NOTIFICATION = 0x6F,
|
|
|
|
STK_DATA_OBJECT_TYPE_LAST_ENVELOPE = 0x70,
|
|
|
|
STK_DATA_OBJECT_TYPE_REGISTRY_APPLICATION_DATA = 0x71,
|
|
|
|
STK_DATA_OBJECT_TYPE_ROUTING_AREA_INFO = 0x73,
|
|
|
|
STK_DATA_OBJECT_TYPE_UPDATE_ATTACH_TYPE = 0x74,
|
2010-06-11 10:39:50 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_REJECTION_CAUSE_CODE = 0x75,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_NMEA_SENTENCE = 0x78,
|
|
|
|
STK_DATA_OBJECT_TYPE_PLMN_LIST = 0x79,
|
|
|
|
STK_DATA_OBJECT_TYPE_BROADCAST_NETWORK_INFO = 0x7A,
|
|
|
|
STK_DATA_OBJECT_TYPE_ACTIVATE_DESCRIPTOR = 0x7B,
|
2010-06-11 10:39:46 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_EPS_PDN_CONN_ACTIVATION_REQ = 0x7C,
|
2010-06-11 10:39:50 +00:00
|
|
|
STK_DATA_OBJECT_TYPE_TRACKING_AREA_ID = 0x7D,
|
2010-02-18 16:58:22 +00:00
|
|
|
};
|
2010-02-18 22:21:48 +00:00
|
|
|
|
|
|
|
enum stk_device_identity_type {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_DEVICE_IDENTITY_TYPE_KEYPAD = 0x01,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_DISPLAY = 0x02,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_EARPIECE = 0x03,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_CARD_READER_0 = 0x10,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_CARD_READER_1 = 0x11,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_CARD_READER_2 = 0x12,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_CARD_READER_3 = 0x13,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_CARD_READER_4 = 0x14,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_CARD_READER_5 = 0x15,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_CARD_READER_6 = 0x16,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_CARD_READER_7 = 0x17,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_CHANNEL_1 = 0x21,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_CHANNEL_7 = 0x27,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_UICC = 0x81,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_TERMINAL = 0x82,
|
|
|
|
STK_DEVICE_IDENTITY_TYPE_NETWORK = 0x83,
|
2010-02-18 22:21:48 +00:00
|
|
|
};
|
2010-02-23 23:10:26 +00:00
|
|
|
|
2010-05-13 10:48:41 +00:00
|
|
|
enum stk_qualifier_get_reader_status_type {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_QUALIFIER_TYPE_CARD_READER_STATUS = 0x00,
|
|
|
|
STK_QUALIFIER_TYPE_CARD_READER_ID = 0x01,
|
2010-05-13 10:48:41 +00:00
|
|
|
};
|
|
|
|
|
2010-02-27 16:09:30 +00:00
|
|
|
enum stk_duration_type {
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_DURATION_TYPE_MINUTES = 0x00,
|
|
|
|
STK_DURATION_TYPE_SECONDS = 0x01,
|
|
|
|
STK_DURATION_TYPE_SECOND_TENTHS = 0x02,
|
2010-02-27 16:09:30 +00:00
|
|
|
};
|
|
|
|
|
2010-03-12 14:19:25 +00:00
|
|
|
/* Defined according to TS 102.223 Section 8.12 */
|
|
|
|
enum stk_result_type {
|
|
|
|
/* 0x00 to 0x1F are used to indicate that command has been performed */
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_RESULT_TYPE_SUCCESS = 0x00,
|
|
|
|
STK_RESULT_TYPE_PARTIAL = 0x01,
|
|
|
|
STK_RESULT_TYPE_MISSING_INFO = 0x02,
|
|
|
|
STK_RESULT_TYPE_REFRESH_WITH_EFS = 0x03,
|
|
|
|
STK_RESULT_TYPE_NO_ICON = 0x04,
|
|
|
|
STK_RESULT_TYPE_CALL_CONTROL = 0x05,
|
|
|
|
STK_RESULT_TYPE_NO_SERVICE = 0x06,
|
|
|
|
STK_RESULT_TYPE_MODIFED = 0x07,
|
|
|
|
STK_RESULT_TYPE_REFRES_NO_NAA = 0x08,
|
|
|
|
STK_RESULT_TYPE_NO_TONE = 0x09,
|
|
|
|
STK_RESULT_TYPE_USER_TERMINATED = 0x10,
|
|
|
|
STK_RESULT_TYPE_GO_BACK = 0x11,
|
|
|
|
STK_RESULT_TYPE_NO_RESPONSE = 0x12,
|
|
|
|
STK_RESULT_TYPE_HELP_REQUESTED = 0x13,
|
2010-09-09 12:31:52 +00:00
|
|
|
STK_RESULT_TYPE_USSD_OR_SS_USER_TERMINATION = 0x14,
|
2010-03-12 14:19:25 +00:00
|
|
|
|
|
|
|
/* 0x20 to 0x2F are used to indicate that SIM should retry */
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_RESULT_TYPE_TERMINAL_BUSY = 0x20,
|
|
|
|
STK_RESULT_TYPE_NETWORK_UNAVAILABLE = 0x21,
|
|
|
|
STK_RESULT_TYPE_USER_REJECT = 0x22,
|
|
|
|
STK_RESULT_TYPE_USER_CANCEL = 0x23,
|
|
|
|
STK_RESULT_TYPE_TIMER_CONFLICT = 0x24,
|
2011-03-30 21:39:38 +00:00
|
|
|
STK_RESULT_TYPE_CALL_CONTROL_TEMPORARY = 0x25,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_RESULT_TYPE_BROWSER_TEMPORARY = 0x26,
|
|
|
|
STK_RESULT_TYPE_MMS_TEMPORARY = 0x27,
|
2010-03-12 14:19:25 +00:00
|
|
|
|
|
|
|
/* 0x30 to 0x3F are used to indicate permanent problems */
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_RESULT_TYPE_NOT_CAPABLE = 0x30,
|
|
|
|
STK_RESULT_TYPE_COMMAND_NOT_UNDERSTOOD = 0x31,
|
|
|
|
STK_RESULT_TYPE_DATA_NOT_UNDERSTOOD = 0x32,
|
|
|
|
STK_RESULT_TYPE_COMMAND_ID_UNKNOWN = 0x33,
|
2010-10-18 08:00:28 +00:00
|
|
|
STK_RESULT_TYPE_SS_RETURN_ERROR = 0x34,
|
|
|
|
STK_RESULT_TYPE_SMS_RP_ERROR = 0x35,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_RESULT_TYPE_MINIMUM_NOT_MET = 0x36,
|
2010-09-09 12:31:52 +00:00
|
|
|
STK_RESULT_TYPE_USSD_RETURN_ERROR = 0x37,
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_RESULT_TYPE_CALL_CONTROL_PERMANENT = 0x39,
|
|
|
|
STK_RESULT_TYPE_BIP_ERROR = 0x3A,
|
|
|
|
STK_RESULT_TYPE_ACCESS_TECHNOLOGY_ERROR = 0x3B,
|
|
|
|
STK_RESULT_TYPE_FRAMES_ERROR = 0x3C,
|
|
|
|
STK_RESULT_TYPE_MMS_ERROR = 0x3D,
|
2010-03-12 14:19:25 +00:00
|
|
|
};
|
|
|
|
|
2010-10-18 08:00:28 +00:00
|
|
|
/* Defined according to TS 102.223 Section 8.12.2 */
|
|
|
|
enum stk_result_addnl_me_pb {
|
|
|
|
STK_RESULT_ADDNL_ME_PB_NO_SPECIFIC_CAUSE = 0x00,
|
|
|
|
STK_RESULT_ADDNL_ME_PB_SCREEN_BUSY = 0x01,
|
|
|
|
STK_RESULT_ADDNL_ME_PB_BUSY_ON_CALL = 0x02,
|
|
|
|
STK_RESULT_ADDNL_ME_PB_SS_BUSY = 0x03,
|
|
|
|
STK_RESULT_ADDNL_ME_PB_NO_SERVICE = 0x04,
|
|
|
|
STK_RESULT_ADDNL_ME_PB_NO_ACCESS = 0x05,
|
|
|
|
STK_RESULT_ADDNL_ME_PB_NO_RADIO_RESOURCE = 0x06,
|
|
|
|
STK_RESULT_ADDNL_ME_PB_NOT_IN_SPEECH_CALL = 0x07,
|
|
|
|
STK_RESULT_ADDNL_ME_PB_USSD_BUSY = 0x08,
|
|
|
|
STK_RESULT_ADDNL_ME_PB_BUSY_ON_SEND_DTMF = 0x09,
|
|
|
|
STK_RESULT_ADDNL_ME_PB_NO_NAA_ACTIVE = 0x0A
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Defined according to TS 31.111 Section 8.12.4 */
|
|
|
|
enum stk_result_addnl_ss_pb {
|
|
|
|
STK_RESULT_ADDNL_SS_PB_NO_SPECIFIC_CAUSE = 0x00
|
|
|
|
};
|
|
|
|
|
2011-04-08 16:33:28 +00:00
|
|
|
/* Defined according to TS 31.111 Section 8.12.4 */
|
|
|
|
enum stk_result_addnl_bip_pb {
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_NO_SPECIFIC_CAUSE = 0x00,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_NO_CHANNEL_AVAIL = 0x01,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_CHANNEL_CLOSED = 0x02,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_CHANNEL_ID_NOT_VALID = 0x03,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_BUFFER_SIZE_NOT_AVAIL = 0x04,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_SECURITY_ERROR = 0x05,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_INTERFACE_NOT_AVAIL = 0x06,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_DEVICE_NOT_REACHABLE = 0x07,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_SERVICE_ERROR = 0x08,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_SERVICE_ID_UNKNOWN = 0x09,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_PORT_NOT_AVAIL = 0x10,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_LAUNCH_PARAMETERS_MISSING = 0x11,
|
|
|
|
STK_RESULT_ADDNL_BIP_PB_APPLICATION_LAUNCH_FAILED = 0x12
|
|
|
|
};
|
|
|
|
|
2010-03-16 02:11:11 +00:00
|
|
|
enum stk_tone_type {
|
2010-03-16 20:14:17 +00:00
|
|
|
STK_TONE_TYPE_DIAL_TONE = 0x01,
|
|
|
|
STK_TONE_TYPE_BUSY_TONE = 0x02,
|
|
|
|
STK_TONE_TYPE_CONGESTION = 0x03,
|
|
|
|
STK_TONE_TYPE_RP_ACK = 0x04,
|
|
|
|
STK_TONE_TYPE_CALL_DROPPED = 0x05,
|
|
|
|
STK_TONE_TYPE_ERROR = 0x06,
|
|
|
|
STK_TONE_TYPE_CALL_WAITING = 0x07,
|
|
|
|
STK_TONE_TYPE_RINGING = 0x08,
|
|
|
|
STK_TONE_TYPE_GENERAL_BEEP = 0x10,
|
|
|
|
STK_TONE_TYPE_POSITIVE_ACK = 0x11,
|
|
|
|
STK_TONE_TYPE_NEGATIVE_ACK = 0x12,
|
|
|
|
STK_TONE_TYPE_INCOMING_CALL = 0x13,
|
|
|
|
STK_TONE_TYPE_INCOMING_SMS = 0x14,
|
|
|
|
STK_TONE_TYPE_CRITICAL_ALERT = 0x15,
|
|
|
|
STK_TONE_TYPE_VIBRATE = 0x20,
|
|
|
|
STK_TONE_TYPE_HAPPY_TONE = 0x31,
|
|
|
|
STK_TONE_TYPE_SAD_TONE = 0x32,
|
|
|
|
STK_TONE_TYPE_URGENT_TONE = 0x33,
|
|
|
|
STK_TONE_TYPE_QUESTION_TONE = 0x34,
|
|
|
|
STK_TONE_TYPE_MESSAGE_TONE = 0x35,
|
|
|
|
STK_TONE_TYPE_MELODY_1 = 0x40,
|
|
|
|
STK_TONE_TYPE_MELODY_2 = 0x41,
|
|
|
|
STK_TONE_TYPE_MELODY_3 = 0x42,
|
|
|
|
STK_TONE_TYPE_MELODY_4 = 0x43,
|
|
|
|
STK_TONE_TYPE_MELODY_5 = 0x44,
|
|
|
|
STK_TONE_TYPE_MELODY_6 = 0x45,
|
|
|
|
STK_TONE_TYPE_MELODY_7 = 0x46,
|
|
|
|
STK_TONE_TYPE_MELODY_8 = 0x47
|
2010-03-16 02:11:11 +00:00
|
|
|
};
|
|
|
|
|
2010-03-31 09:16:55 +00:00
|
|
|
enum stk_event_type {
|
|
|
|
STK_EVENT_TYPE_MT_CALL = 0x00,
|
|
|
|
STK_EVENT_TYPE_CALL_CONNECTED = 0x01,
|
|
|
|
STK_EVENT_TYPE_CALL_DISCONNECTED = 0x02,
|
|
|
|
STK_EVENT_TYPE_LOCATION_STATUS = 0x03,
|
|
|
|
STK_EVENT_TYPE_USER_ACTIVITY = 0x04,
|
|
|
|
STK_EVENT_TYPE_IDLE_SCREEN_AVAILABLE = 0x05,
|
|
|
|
STK_EVENT_TYPE_CARD_READER_STATUS = 0x06,
|
|
|
|
STK_EVENT_TYPE_LANGUAGE_SELECTION = 0x07,
|
|
|
|
STK_EVENT_TYPE_BROWSER_TERMINATION = 0x08,
|
|
|
|
STK_EVENT_TYPE_DATA_AVAILABLE = 0x09,
|
|
|
|
STK_EVENT_TYPE_CHANNEL_STATUS = 0x0A,
|
|
|
|
STK_EVENT_TYPE_SINGLE_ACCESS_TECHNOLOGY_CHANGE = 0x0B,
|
|
|
|
STK_EVENT_TYPE_DISPLAY_PARAMETERS_CHANGED = 0x0C,
|
|
|
|
STK_EVENT_TYPE_LOCAL_CONNECTION = 0x0D,
|
|
|
|
STK_EVENT_TYPE_NETWORK_SEARCH_MODE_CHANGE = 0x0E,
|
|
|
|
STK_EVENT_TYPE_BROWSING_STATUS = 0x0F,
|
|
|
|
STK_EVENT_TYPE_FRAMES_INFORMATION_CHANGE = 0x10,
|
|
|
|
STK_EVENT_TYPE_I_WLAN_ACCESS_STATUS = 0x11,
|
|
|
|
STK_EVENT_TYPE_NETWORK_REJECTION = 0x12,
|
|
|
|
STK_EVENT_TYPE_HCI_CONNECTIVITY_EVENT = 0x13,
|
|
|
|
STK_EVENT_TYPE_MULTIPLE_ACCESS_TECHNOLOGIES_CHANGE = 0x14
|
|
|
|
};
|
|
|
|
|
2010-03-31 09:16:57 +00:00
|
|
|
enum stk_service_state {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_NORMAL_SERVICE = 0x00,
|
|
|
|
STK_LIMITED_SERVICE = 0x01,
|
|
|
|
STK_NO_SERVICE = 0x02
|
2010-03-31 09:16:57 +00:00
|
|
|
};
|
|
|
|
|
2010-03-31 09:17:00 +00:00
|
|
|
enum stk_icon_qualifier {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_ICON_QUALIFIER_TYPE_SELF_EXPLANATORY = 0x00,
|
2010-03-31 09:17:00 +00:00
|
|
|
STK_ICON_QUALIFIER_TYPE_NON_SELF_EXPLANATORY = 0x01
|
|
|
|
};
|
|
|
|
|
2010-05-13 10:48:37 +00:00
|
|
|
enum stk_ins {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_INS_DEACTIVATE_FILE = 0x04,
|
|
|
|
STK_INS_ERASE_RECORDS = 0x0C,
|
|
|
|
STK_INS_ERASE_BINARY_0E = 0x0E,
|
|
|
|
STK_INS_ERASE_BINARY_0F = 0x0F,
|
|
|
|
STK_INS_PERFORM_SCQL_OPERATION = 0x10,
|
|
|
|
STK_INS_PERFORM_TRANSACTION_OPERATION = 0x12,
|
|
|
|
STK_INS_PERFORM_USER_OPERATION = 0x14,
|
|
|
|
STK_INS_VERIFY_20 = 0x20,
|
|
|
|
STK_INS_VERIFY_21 = 0x21,
|
|
|
|
STK_INS_MANAGE_SECURITY_ENVIRONMENT = 0x22,
|
|
|
|
STK_INS_CHANGE_REFERENCE_DATA = 0x24,
|
|
|
|
STK_INS_DISABLE_VERIFICATION_REQUIREMENT = 0x26,
|
|
|
|
STK_INS_ENABLE_VERIFICATION_REQUIREMENT = 0x28,
|
|
|
|
STK_INS_PERFORM_SECURITY_OPERATION = 0x2A,
|
|
|
|
STK_INS_RESET_RETRY_COUNTER = 0x2C,
|
|
|
|
STK_INS_ACTIVATE_FILE = 0x44,
|
|
|
|
STK_INS_GENERATE_ASYMMETRIC_KEY_PAIR = 0x46,
|
|
|
|
STK_INS_MANAGE_CHANNEL = 0x70,
|
|
|
|
STK_INS_EXTERNAL_AUTHENTICATE = 0x82,
|
|
|
|
STK_INS_GET_CHALLENGE = 0x84,
|
|
|
|
STK_INS_GENERAL_AUTHENTICATE_86 = 0x86,
|
|
|
|
STK_INS_GENERAL_AUTHENTICATE_87 = 0x87,
|
|
|
|
STK_INS_INTERNAL_AUTHENTICATE = 0x88,
|
|
|
|
STK_INS_SEARCH_BINARY_A0 = 0xA0,
|
|
|
|
STK_INS_SEARCH_BINARY_A1 = 0xA1,
|
|
|
|
STK_INS_SEARCH_RECORD = 0xA2,
|
|
|
|
STK_INS_SELECT = 0xA4,
|
|
|
|
STK_INS_READ_BINARY_B0 = 0xB0,
|
|
|
|
STK_INS_READ_BINARY_B1 = 0xB1,
|
|
|
|
STK_INS_READ_RECORDS_B2 = 0xB2,
|
|
|
|
STK_INS_READ_RECORDS_B3 = 0xB3,
|
|
|
|
STK_INS_GET_RESPONSE = 0xC0,
|
|
|
|
STK_INS_ENVELOPE_C2 = 0xC2,
|
2010-05-13 20:31:21 +00:00
|
|
|
STK_INS_ENVELOPE_C3 = 0xC3,
|
|
|
|
STK_INS_GET_DATA_CA = 0xCA,
|
|
|
|
STK_INS_GET_DATA_CB = 0xCB,
|
|
|
|
STK_INS_WRITE_BINARY_D0 = 0xD0,
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_INS_WRITE_BINARY_D1 = 0xD1,
|
|
|
|
STK_INS_WRITE_RECORD = 0xD2,
|
|
|
|
STK_INS_UPDATE_BINARY_D6 = 0xD6,
|
|
|
|
STK_INS_UPDATE_BINARY_D7 = 0xD7,
|
|
|
|
STK_INS_PUT_DATA_DA = 0xDA,
|
|
|
|
STK_INS_PUT_DATA_DB = 0xDB,
|
|
|
|
STK_INS_UPDATE_RECORD_DC = 0xDC,
|
|
|
|
STK_INS_UPDATE_RECORD_DD = 0xDD,
|
|
|
|
STK_INS_CREATE_FILE = 0xE0,
|
|
|
|
STK_INS_APPEND_RECORD = 0xE2,
|
|
|
|
STK_INS_DELETE_FILE = 0xE4,
|
|
|
|
STK_INS_TERMINATE_DF = 0xE6,
|
|
|
|
STK_INS_TERMINATE_EF = 0xE8,
|
|
|
|
STK_INS_TERMINATE_CARD_USAGE = 0xFE
|
2010-05-13 10:48:37 +00:00
|
|
|
};
|
|
|
|
|
2010-04-02 06:20:40 +00:00
|
|
|
enum stk_browser_id {
|
|
|
|
STK_BROWSER_ID_DEFAULT = 0x00,
|
|
|
|
STK_BROWSER_ID_WML = 0x01,
|
|
|
|
STK_BROWSER_ID_HTML = 0x02,
|
|
|
|
STK_BROWSER_ID_XHTML = 0x03,
|
|
|
|
STK_BROWSER_ID_CHTML = 0x04
|
|
|
|
};
|
|
|
|
|
2010-04-06 10:06:37 +00:00
|
|
|
enum stk_bearer {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_BEARER_SMS = 0x00,
|
2010-04-06 10:06:37 +00:00
|
|
|
STK_BEARER_CS_DATA = 0x01,
|
|
|
|
STK_BEARER_GSM_3G = 0x02,
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_BEARER_PS = 0x03
|
2010-04-06 10:06:37 +00:00
|
|
|
};
|
|
|
|
|
2010-04-06 10:06:40 +00:00
|
|
|
enum stk_browser_termination_cause {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_BROWSER_USER_TERMINATION = 0x00,
|
|
|
|
STK_BROWSER_ERROR_TERMINATION = 0x01
|
2010-04-06 10:06:40 +00:00
|
|
|
};
|
|
|
|
|
2011-03-31 16:25:13 +00:00
|
|
|
/* Defined in TS 31.111 Section 8.52 */
|
2010-04-06 10:06:41 +00:00
|
|
|
enum stk_bearer_type {
|
2011-03-31 16:25:13 +00:00
|
|
|
STK_BEARER_TYPE_CS = 0x01,
|
|
|
|
STK_BEARER_TYPE_GPRS_UTRAN = 0x02,
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_BEARER_TYPE_DEFAULT = 0x03,
|
|
|
|
STK_BEARER_TYPE_INDEPENDENT = 0x04,
|
2010-04-06 10:06:41 +00:00
|
|
|
STK_BEARER_TYPE_BLUETOOTH = 0x05,
|
|
|
|
STK_BEARER_TYPE_IRDA = 0x06,
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_BEARER_TYPE_RS232 = 0x07,
|
2011-03-31 16:25:13 +00:00
|
|
|
STK_BEARER_TYPE_TIA_EIA_IS_820 = 0x08,
|
|
|
|
STK_BEARER_TYPE_UTRAN_WITH_EXT_PARAMS = 0x09,
|
|
|
|
STK_BEARER_TYPE_I_WLAN = 0x0A,
|
|
|
|
STK_BEARER_TYPE_EUTRAN_MAPPED_UTRAN = 0x0B,
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_BEARER_TYPE_USB = 0x10
|
2010-04-06 10:06:41 +00:00
|
|
|
};
|
|
|
|
|
2010-04-06 10:06:47 +00:00
|
|
|
enum stk_address_type {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_ADDRESS_AUTO = -1,
|
|
|
|
STK_ADDRESS_IPV4 = 0x21,
|
|
|
|
STK_ADDRESS_IPV6 = 0x57
|
2010-04-06 10:06:47 +00:00
|
|
|
};
|
|
|
|
|
2010-04-20 06:14:57 +00:00
|
|
|
enum stk_access_technology_type {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_ACCESS_TECHNOLOGY_GSM = 0x00,
|
2010-04-20 06:14:57 +00:00
|
|
|
STK_ACCESS_TECHNOLOGY_TIA_EIA_553 = 0x01,
|
|
|
|
STK_ACCESS_TECHNOLOGY_TIA_EIA_136_C = 0x02,
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_ACCESS_TECHNOLOGY_UTRAN = 0x03,
|
|
|
|
STK_ACCESS_TECHNOLOGY_TETRA = 0x04,
|
|
|
|
STK_ACCESS_TECHNOLOGY_TIA_EIA_95 = 0x05,
|
2010-04-20 06:14:57 +00:00
|
|
|
STK_ACCESS_TECHNOLOGY_CDMA2000_1X = 0x06,
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_ACCESS_TECHNOLOGY_CDMA2000_HRPD = 0x07,
|
|
|
|
STK_ACCESS_TECHNOLOGY_EUTRAN = 0x08
|
2010-04-20 06:14:57 +00:00
|
|
|
};
|
|
|
|
|
2010-04-21 04:55:47 +00:00
|
|
|
enum stk_technology_id {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_TECHNOLOGY_INDEPENDENT = 0x00,
|
|
|
|
STK_TECHNOLOGY_BLUETOOTH = 0x01,
|
|
|
|
STK_TECHNOLOGY_IRDA = 0x02,
|
|
|
|
STK_TECHNOLOGY_RS232 = 0x03,
|
|
|
|
STK_TECHNOLOGY_USB = 0x04
|
2010-04-21 04:55:47 +00:00
|
|
|
};
|
|
|
|
|
2010-04-21 04:55:59 +00:00
|
|
|
enum stk_battery_state {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_BATTERY_VERY_LOW = 0x00,
|
|
|
|
STK_BATTERY_LOW = 0x01,
|
|
|
|
STK_BATTERY_AVERAGE = 0x02,
|
|
|
|
STK_BATTERY_GOOD = 0x03,
|
|
|
|
STK_BATTERY_FULL = 0x04
|
2010-04-21 04:55:59 +00:00
|
|
|
};
|
|
|
|
|
2010-04-22 15:12:19 +00:00
|
|
|
enum stk_frame_layout_type {
|
2010-06-15 16:03:53 +00:00
|
|
|
STK_LAYOUT_HORIZONTAL = 0x01,
|
|
|
|
STK_LAYOUT_VERTICAL = 0x02
|
2010-04-22 15:12:19 +00:00
|
|
|
};
|
|
|
|
|
2010-04-22 15:12:30 +00:00
|
|
|
enum stk_broadcast_network_technology {
|
|
|
|
STK_BROADCAST_NETWORK_DVB_H = 0x00,
|
|
|
|
STK_BROADCAST_NETWORK_DVB_T = 0x01,
|
|
|
|
STK_BROADCAST_NETWORK_DVB_SH = 0x02,
|
|
|
|
STK_BROADCAST_NETWORK_T_DMB = 0x03
|
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:50 +00:00
|
|
|
enum stk_i_wlan_access_status {
|
|
|
|
STK_I_WLAN_STATUS_NO_COVERAGE = 0x00,
|
|
|
|
STK_I_WLAN_STATUS_NOT_CONNECTED = 0x01,
|
|
|
|
STK_I_WLAN_STATUS_CONNECTED = 0x02,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum stk_update_attach_type {
|
|
|
|
STK_UPDATE_ATTACH_NORMAL_LOCATION_UPDATING = 0x00,
|
|
|
|
STK_UPDATE_ATTACH_PERIODIC_UPDATING = 0x01,
|
|
|
|
STK_UPDATE_ATTACH_IMSI_ATTACH = 0x02,
|
|
|
|
STK_UPDATE_ATTACH_GPRS_ATTACH = 0x03,
|
|
|
|
STK_UPDATE_ATTACH_GPRS_IMSI_ATTACH = 0x04,
|
|
|
|
STK_UPDATE_ATTACH_RA_UPDATING = 0x05,
|
|
|
|
STK_UPDATE_ATTACH_RA_LA_UPDATING = 0x06,
|
|
|
|
STK_UPDATE_ATTACH_RA_LA_UPDATING_IMSI_ATTACH = 0x07,
|
|
|
|
STK_UPDATE_ATTACH_PERIODIC_RA_UPDATING = 0x08,
|
|
|
|
STK_UPDATE_ATTACH_EPS_ATTACH = 0x09,
|
|
|
|
STK_UPDATE_ATTACH_EPS_IMSI_ATTACH = 0x0a,
|
|
|
|
STK_UPDATE_ATTACH_TA_UPDATING = 0x0b,
|
|
|
|
STK_UPDATE_ATTACH_TA_LA_UPDATING = 0x0c,
|
|
|
|
STK_UPDATE_ATTACH_TA_LA_UPDATING_IMSI_ATTACH = 0x0d,
|
|
|
|
STK_UPDATE_ATTACH_PERIDIC_TA_UPDATING = 0x0e,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum stk_rejection_cause_code {
|
|
|
|
/* MM and GMM codes (GERAN/UTRAN) */
|
|
|
|
STK_CAUSE_GMM_IMSI_UNKNOWN_IN_HLR = 0x02,
|
|
|
|
STK_CAUSE_GMM_ILLEGAL_MS = 0x03,
|
|
|
|
STK_CAUSE_GMM_IMSI_UNKNOWN_IN_VLR = 0x04,
|
|
|
|
STK_CAUSE_GMM_IMEI_NOT_ACCEPTED = 0x05,
|
|
|
|
STK_CAUSE_GMM_ILLEGAL_ME = 0x06,
|
|
|
|
STK_CAUSE_GMM_GPRS_NOT_ALLOWED = 0x07,
|
|
|
|
STK_CAUSE_GMM_GPRS_AND_NON_GPRS_NOT_ALLOWED = 0x08,
|
|
|
|
STK_CAUSE_GMM_IMEI_NOT_DERIVED_BY_NETWORK = 0x09,
|
|
|
|
STK_CAUSE_GMM_IMPLICITLY_DETACHED = 0x0a,
|
|
|
|
STK_CAUSE_GMM_PLMN_NOT_ALLOWED = 0x0b,
|
|
|
|
STK_CAUSE_GMM_LAC_NOT_ALLOWED = 0x0c,
|
|
|
|
STK_CAUSE_GMM_ROAMING_NOT_ALLOWED = 0x0d,
|
|
|
|
STK_CAUSE_GMM_GPRS_NOT_ALLOWED_IN_PLMN = 0x0e,
|
|
|
|
STK_CAUSE_GMM_NO_SUITABLE_CELLS = 0x0f,
|
|
|
|
STK_CAUSE_GMM_MSC_TEMPORARILY_UNREACHABLE = 0x10,
|
|
|
|
STK_CAUSE_GMM_NETWORK_FAILURE = 0x11,
|
|
|
|
STK_CAUSE_GMM_MAC_FAILURE = 0x14,
|
|
|
|
STK_CAUSE_GMM_SYNCH_FAILURE = 0x15,
|
|
|
|
STK_CAUSE_GMM_CONGESTION = 0x16,
|
|
|
|
STK_CAUSE_GMM_GSM_AUTHENTICATION_UNACCEPTABLE = 0x17,
|
|
|
|
STK_CAUSE_GMM_NOT_AUTHORISED_FOR_CSG = 0x19,
|
|
|
|
STK_CAUSE_GMM_SERVICE_OPTION_NOT_SUPPORTED = 0x20,
|
|
|
|
STK_CAUSE_GMM_SERVICE_OPTION_NOT_SUBSCRIBED = 0x21,
|
|
|
|
STK_CAUSE_GMM_SERVICE_OPTION_TEMPORARY_DEFUNC = 0x22,
|
|
|
|
STK_CAUSE_GMM_CALL_NOT_IDENTIFIED = 0x26,
|
|
|
|
STK_CAUSE_GMM_NO_PDP_CONTEXT_ACTIVATED = 0x28,
|
|
|
|
STK_CAUSE_GMM_RETRY_ON_NEW_CELL = 0x30, /* to 0x3f */
|
|
|
|
STK_CAUSE_GMM_SEMANTICALLY_INCORRECT_MESSAGE = 0x5f,
|
|
|
|
STK_CAUSE_GMM_INVALID_MANDATORY_INFO = 0x60,
|
|
|
|
STK_CAUSE_GMM_MESSAGE_TYPE_UNKNOWN = 0x61,
|
|
|
|
STK_CAUSE_GMM_MESSAGE_TYPE_INCOMPATIBLE_STATE = 0x62,
|
|
|
|
STK_CAUSE_GMM_IE_UNKNOWN = 0x63,
|
|
|
|
STK_CAUSE_GMM_CONDITIONAL_IE_ERROR = 0x64,
|
|
|
|
STK_CAUSE_GMM_MESSAGE_INCOMPATIBLE_WITH_STATE = 0x65,
|
|
|
|
STK_CAUSE_GMM_PROTOCOL_ERROR = 0x6f,
|
|
|
|
/* EMM codes (E-UTRAN) */
|
|
|
|
STK_CAUSE_EMM_IMSI_UNKNOWN_IN_HSS = 0x02,
|
|
|
|
STK_CAUSE_EMM_ILLEGAL_UE = 0x03,
|
|
|
|
STK_CAUSE_EMM_ILLEGAL_ME = 0x06,
|
|
|
|
STK_CAUSE_EMM_EPS_NOT_ALLOWED = 0x07,
|
|
|
|
STK_CAUSE_EMM_EPS_AND_NON_EPS_NOT_ALLOWED = 0x08,
|
|
|
|
STK_CAUSE_EMM_IMEI_NOT_DERIVED_BY_NETWORK = 0x09,
|
|
|
|
STK_CAUSE_EMM_IMPLICITLY_DETACHED = 0x0a,
|
|
|
|
STK_CAUSE_EMM_PLMN_NOT_ALLOWED = 0x0b,
|
|
|
|
STK_CAUSE_EMM_TAC_NOT_ALLOWED = 0x0c,
|
|
|
|
STK_CAUSE_EMM_ROAMING_NOT_ALLOWED = 0x0d,
|
|
|
|
STK_CAUSE_EMM_EPS_NOT_ALLOWED_IN_PLMN = 0x0e,
|
|
|
|
STK_CAUSE_EMM_NO_SUITABLE_CELLS = 0x0f,
|
|
|
|
STK_CAUSE_EMM_MSC_TEMPORARILY_UNREACHABLE = 0x10,
|
|
|
|
STK_CAUSE_EMM_NETWORK_FAILURE = 0x11,
|
|
|
|
STK_CAUSE_EMM_MAC_FAILURE = 0x14,
|
|
|
|
STK_CAUSE_EMM_SYNCH_FAILURE = 0x15,
|
|
|
|
STK_CAUSE_EMM_CONGESTION = 0x16,
|
|
|
|
STK_CAUSE_EMM_SECURITY_MODE_REJECTED = 0x18,
|
|
|
|
STK_CAUSE_EMM_NOT_AUTHORISED_FOR_CSG = 0x19,
|
|
|
|
STK_CAUSE_EMM_CS_FALLBACK_NOT_ALLOWED = 0x26,
|
|
|
|
STK_CAUSE_EMM_CS_DOMAIN_TEMPORARY_UNAVAILABLE = 0x27,
|
|
|
|
STK_CAUSE_EMM_NO_EPS_BEARER_CONTEXT_ACTIVATED = 0x28,
|
|
|
|
STK_CAUSE_EMM_SEMANTICALLY_INCORRECT_MESSAGE = 0x5f,
|
|
|
|
STK_CAUSE_EMM_INVALID_MANDATORY_INFO = 0x60,
|
|
|
|
STK_CAUSE_EMM_MESSAGE_TYPE_UNKNOWN = 0x61,
|
|
|
|
STK_CAUSE_EMM_MESSAGE_TYPE_INCOMPATIBLE_STATE = 0x62,
|
|
|
|
STK_CAUSE_EMM_IE_UNKNOWN = 0x63,
|
|
|
|
STK_CAUSE_EMM_CONDITIONAL_IE_ERROR = 0x64,
|
|
|
|
STK_CAUSE_EMM_MESSAGE_INCOMPATIBLE_WITH_STATE = 0x65,
|
|
|
|
STK_CAUSE_EMM_PROTOCOL_ERROR = 0x6f,
|
|
|
|
};
|
|
|
|
|
2010-06-17 10:35:11 +00:00
|
|
|
enum stk_me_status {
|
2010-09-03 21:34:38 +00:00
|
|
|
STK_ME_STATUS_IDLE = 0x00,
|
|
|
|
STK_ME_STATUS_NOT_IDLE = 0x01
|
2010-06-17 10:35:11 +00:00
|
|
|
};
|
|
|
|
|
2010-07-26 18:27:33 +00:00
|
|
|
enum stk_img_scheme {
|
|
|
|
STK_IMG_SCHEME_BASIC = 0x11,
|
|
|
|
STK_IMG_SCHEME_COLOR = 0x21,
|
|
|
|
STK_IMG_SCHEME_TRANSPARENCY = 0x22,
|
|
|
|
};
|
|
|
|
|
2011-03-31 16:25:13 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.6 */
|
|
|
|
enum stk_qualifier_open_channel {
|
|
|
|
STK_OPEN_CHANNEL_FLAG_IMMEDIATE = 0x01,
|
|
|
|
STK_OPEN_CHANNEL_FLAG_AUTO_RECONNECT = 0x02,
|
|
|
|
STK_OPEN_CHANNEL_FLAG_BACKGROUND = 0x04,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Defined in TS 102.223 Section 8.6 */
|
|
|
|
enum stk_qualifier_send_data {
|
|
|
|
STK_SEND_DATA_STORE_DATA = 0x00,
|
|
|
|
STK_SEND_DATA_IMMEDIATELY = 0x01,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Defined in TS 102.223 Section 8.56 */
|
|
|
|
enum stk_channel_status {
|
|
|
|
STK_CHANNEL_PACKET_DATA_SERVICE_NOT_ACTIVATED = 0x00,
|
|
|
|
STK_CHANNEL_PACKET_DATA_SERVICE_ACTIVATED = 0x01,
|
|
|
|
STK_CHANNEL_TCP_IN_CLOSED_STATE = 0x02,
|
|
|
|
STK_CHANNEL_TCP_IN_LISTEN_STATE = 0x03,
|
|
|
|
STK_CHANNEL_TCP_IN_ESTABLISHED_STATE = 0x04,
|
|
|
|
STK_CHANNEL_LINK_DROPPED = 0x05,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Defined in TS 102.223 Section 8.59 */
|
|
|
|
enum stk_transport_protocol_type {
|
|
|
|
STK_TRANSPORT_PROTOCOL_UDP_CLIENT_REMOTE = 0x01,
|
|
|
|
STK_TRANSPORT_PROTOCOL_TCP_CLIENT_REMOTE = 0x02,
|
|
|
|
STK_TRANSPORT_PROTOCOL_TCP_SERVER = 0x03,
|
|
|
|
STK_TRANSPORT_PROTOCOL_UDP_CLIENT_LOCAL = 0x04,
|
|
|
|
STK_TRANSPORT_PROTOCOL_TCP_CLIENT_LOCAL = 0x05,
|
|
|
|
STK_TRANSPORT_PROTOCOL_DIRECT = 0x06,
|
|
|
|
};
|
|
|
|
|
2010-03-31 09:16:59 +00:00
|
|
|
/* For data object that only has a byte array with undetermined length */
|
|
|
|
struct stk_common_byte_array {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t *array;
|
2010-03-31 09:16:59 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-03-05 04:34:28 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.1 */
|
|
|
|
struct stk_address {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t ton_npi;
|
2010-03-05 04:34:28 +00:00
|
|
|
char *number;
|
|
|
|
};
|
|
|
|
|
2010-03-10 18:53:09 +00:00
|
|
|
/*
|
|
|
|
* Defined in TS 102.223 Section 8.3
|
|
|
|
*
|
|
|
|
* The maximum size of the subaddress is different depending on the referenced
|
|
|
|
* specification. According to TS 24.008 Section 10.5.4.8: "The called party
|
|
|
|
* subaddress is a type 4 information element with a minimum length of 2 octets
|
|
|
|
* and a maximum length of 23 octets"
|
|
|
|
*
|
|
|
|
* According to TS 31.102 Section 4.4.2.4: "The subaddress data contains
|
2010-09-21 19:18:15 +00:00
|
|
|
* information as defined for this purpose in TS 24.008 [9]. All information
|
|
|
|
* defined in TS 24.008, except the information element identifier, shall be
|
2010-03-10 18:53:09 +00:00
|
|
|
* stored in the USIM. The length of this subaddress data can be up to 22
|
|
|
|
* bytes."
|
|
|
|
*/
|
2010-03-05 04:43:34 +00:00
|
|
|
struct stk_subaddress {
|
2018-12-29 21:26:37 +00:00
|
|
|
bool has_subaddr;
|
|
|
|
uint8_t len;
|
|
|
|
uint8_t subaddr[23];
|
2010-03-05 04:43:34 +00:00
|
|
|
};
|
|
|
|
|
2010-03-11 20:43:59 +00:00
|
|
|
/*
|
|
|
|
* Defined in TS 102.223 Section 8.4
|
|
|
|
*
|
|
|
|
* According to 24.008 Section 10.5.4.5 "The bearer capability is a type 4
|
|
|
|
* information element with a minimum length of 3 octets and a maximum length
|
2010-09-21 19:18:15 +00:00
|
|
|
* of 16 octets."
|
2010-03-11 20:43:59 +00:00
|
|
|
*
|
|
|
|
* According to TS 31.102 Section 4.2.38 the CCP length is 15 bytes.
|
|
|
|
*
|
|
|
|
* The CCP structure is not decoded, but stored as is from the CTLV
|
|
|
|
*/
|
|
|
|
struct stk_ccp {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t len;
|
|
|
|
uint8_t ccp[16];
|
2010-03-05 04:45:31 +00:00
|
|
|
};
|
|
|
|
|
2010-06-13 09:43:18 +00:00
|
|
|
/* Defined in TS 31.111 Section 8.5 */
|
|
|
|
struct stk_cbs_page {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t len;
|
|
|
|
uint8_t page[88];
|
2010-06-13 09:43:18 +00:00
|
|
|
};
|
|
|
|
|
2010-02-27 16:19:19 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.8 interval values of 0x00 are reserved.
|
|
|
|
* We use this to denote empty duration objects.
|
|
|
|
*/
|
|
|
|
struct stk_duration {
|
|
|
|
enum stk_duration_type unit;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t interval;
|
2010-02-27 16:19:19 +00:00
|
|
|
};
|
|
|
|
|
2010-03-05 05:40:40 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.9 */
|
|
|
|
struct stk_item {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t id;
|
2010-03-05 05:40:40 +00:00
|
|
|
char *text;
|
|
|
|
};
|
|
|
|
|
2010-03-12 13:51:58 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.11, the maximum length should never be set
|
|
|
|
* to 0.
|
|
|
|
*/
|
|
|
|
struct stk_response_length {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t min;
|
|
|
|
uint8_t max;
|
2010-03-12 13:51:58 +00:00
|
|
|
};
|
|
|
|
|
2010-03-05 08:40:20 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.12 */
|
|
|
|
struct stk_result {
|
2010-03-12 14:19:25 +00:00
|
|
|
enum stk_result_type type;
|
2010-03-05 08:40:20 +00:00
|
|
|
unsigned int additional_len;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t *additional;
|
2010-03-05 08:40:20 +00:00
|
|
|
};
|
|
|
|
|
2010-06-13 09:43:11 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.14 */
|
|
|
|
struct stk_ss {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t ton_npi;
|
2010-06-13 09:43:11 +00:00
|
|
|
char *ss;
|
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:46 +00:00
|
|
|
/* Defined in TS 131.111 Section 8.17. Length limit of 160 chars in 23.028 */
|
|
|
|
struct stk_ussd_string {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t dcs;
|
|
|
|
uint8_t string[160];
|
2010-06-11 10:39:46 +00:00
|
|
|
int len;
|
|
|
|
};
|
|
|
|
|
2010-09-21 19:18:15 +00:00
|
|
|
/*
|
|
|
|
* Define the struct of single file in TS102.223 Section 8.18.
|
2010-03-31 09:16:53 +00:00
|
|
|
* According to TS 11.11 Section 6.2, each file id has two bytes, and the
|
|
|
|
* maximum Dedicated File level is 2. So the maximum size of file is 8, which
|
|
|
|
* contains two bytes of Master File, 2 bytes of 1st level Dedicated File,
|
|
|
|
* 2 bytes of 2nd level Dedicated File and 2 bytes of Elementary File.
|
|
|
|
*/
|
|
|
|
struct stk_file {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t file[8];
|
2010-03-31 09:16:53 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-03-25 16:07:32 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.19 */
|
|
|
|
struct stk_location_info {
|
|
|
|
char mnc[OFONO_MAX_MNC_LENGTH + 1];
|
|
|
|
char mcc[OFONO_MAX_MCC_LENGTH + 1];
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t lac_tac;
|
|
|
|
bool has_ci;
|
|
|
|
uint16_t ci;
|
|
|
|
bool has_ext_ci;
|
|
|
|
uint16_t ext_ci;
|
|
|
|
bool has_eutran_ci;
|
|
|
|
uint32_t eutran_ci;
|
2010-03-25 16:07:32 +00:00
|
|
|
};
|
|
|
|
|
2010-03-31 09:16:54 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.24 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs.
|
|
|
|
*/
|
|
|
|
struct stk_items_next_action_indicator {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t list[127];
|
2010-03-31 09:16:54 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-03-31 09:16:55 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.25, there are 21 kinds of event type and no
|
|
|
|
* one should appear more than once.
|
|
|
|
*/
|
|
|
|
struct stk_event_list {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t list[21];
|
2010-03-31 09:16:55 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-03-31 09:16:56 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.26, the maximum length of cause is 30.
|
|
|
|
*/
|
|
|
|
struct stk_cause {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t cause[30];
|
2010-03-31 09:16:56 +00:00
|
|
|
unsigned int len;
|
2018-12-29 21:26:37 +00:00
|
|
|
bool has_cause;
|
2010-03-31 09:16:56 +00:00
|
|
|
};
|
|
|
|
|
2010-03-31 09:16:58 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.28 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs.
|
|
|
|
*/
|
|
|
|
struct stk_transaction_id {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t list[127];
|
2010-03-31 09:16:58 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-06-13 09:43:19 +00:00
|
|
|
/*
|
|
|
|
* According to 31.111 Section 8.29 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs. Each channel
|
|
|
|
* is represented as 10 bits, so the maximum number of channel is 127*8/10=101.
|
|
|
|
*/
|
|
|
|
struct stk_bcch_channel_list {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t channels[101];
|
2010-06-13 09:43:19 +00:00
|
|
|
unsigned int num;
|
2018-12-29 21:26:37 +00:00
|
|
|
bool has_list;
|
2010-06-13 09:43:19 +00:00
|
|
|
};
|
|
|
|
|
2010-03-31 09:16:53 +00:00
|
|
|
/*
|
|
|
|
* Defined in TS 102.223 Section 8.31
|
|
|
|
* Icon ID denotes a file on the SIM filesystem. Since EF cannot have record
|
|
|
|
* ids of 0, we use icon_id with 0 to denote empty icon_identifier objects
|
2010-03-23 04:33:49 +00:00
|
|
|
*/
|
2010-03-31 09:17:02 +00:00
|
|
|
struct stk_icon_id {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t qualifier;
|
|
|
|
uint8_t id;
|
2010-03-23 04:33:49 +00:00
|
|
|
};
|
|
|
|
|
2010-03-31 09:17:01 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.32 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs. This size also
|
|
|
|
* includes icon list qualifier for 1 byte, so the maxmimum size of icon
|
|
|
|
* identifier list is 126.
|
|
|
|
*/
|
|
|
|
struct stk_item_icon_id_list {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t qualifier;
|
|
|
|
uint8_t list[126];
|
2010-03-31 09:17:01 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:50 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.33 */
|
|
|
|
struct stk_reader_status {
|
|
|
|
int id;
|
2018-12-29 21:26:37 +00:00
|
|
|
bool removable;
|
|
|
|
bool present;
|
|
|
|
bool id1_size;
|
|
|
|
bool card_present;
|
|
|
|
bool card_powered;
|
2010-06-11 10:39:50 +00:00
|
|
|
};
|
|
|
|
|
2010-04-02 06:20:27 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.34 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs.
|
|
|
|
*/
|
|
|
|
struct stk_card_atr {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t atr[127];
|
2010-04-02 06:20:27 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-04-02 06:20:28 +00:00
|
|
|
/*
|
|
|
|
* Defined in TS 102.223 Section 8.35. According to it, the maximum size
|
|
|
|
* of data is 236.
|
|
|
|
*/
|
|
|
|
struct stk_c_apdu {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t cla;
|
|
|
|
uint8_t ins;
|
|
|
|
uint8_t p1;
|
|
|
|
uint8_t p2;
|
|
|
|
uint8_t lc;
|
|
|
|
uint8_t data[236];
|
|
|
|
bool has_le;
|
|
|
|
uint8_t le;
|
2010-04-02 06:20:28 +00:00
|
|
|
};
|
|
|
|
|
2010-04-02 06:20:29 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.36. According to it, the maximum size
|
|
|
|
* of data is 237.
|
|
|
|
*/
|
|
|
|
struct stk_r_apdu {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t sw1;
|
|
|
|
uint8_t sw2;
|
|
|
|
uint8_t data[237];
|
2010-04-02 06:20:29 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-04-02 06:20:32 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.38 */
|
|
|
|
struct stk_timer_value {
|
2018-12-29 21:26:37 +00:00
|
|
|
bool has_value;
|
|
|
|
uint8_t hour;
|
|
|
|
uint8_t minute;
|
|
|
|
uint8_t second;
|
2010-04-02 06:20:32 +00:00
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:46 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.42 */
|
|
|
|
struct stk_bc_repeat {
|
2018-12-29 21:26:37 +00:00
|
|
|
bool has_bc_repeat;
|
|
|
|
uint8_t value;
|
2010-06-11 10:39:46 +00:00
|
|
|
};
|
|
|
|
|
2010-06-17 10:35:11 +00:00
|
|
|
/* Defined in TS 31.111 Section 8.46 */
|
|
|
|
struct stk_timing_advance {
|
2018-12-29 21:26:37 +00:00
|
|
|
bool has_value;
|
2010-06-17 10:35:11 +00:00
|
|
|
enum stk_me_status status;
|
|
|
|
/*
|
|
|
|
* Contains bit periods number according to 3GPP TS
|
|
|
|
* 44.118 Section 9.3.106 / 3GPP TS 44.018 Section
|
|
|
|
* 10.5.2.40.1, not microseconds
|
|
|
|
*/
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t advance;
|
2010-06-17 10:35:11 +00:00
|
|
|
};
|
|
|
|
|
2011-03-31 16:25:13 +00:00
|
|
|
/* Bearer parameters for GPRS/UTRAN Packet Service/E-UTRAN */
|
|
|
|
struct stk_gprs_bearer_parameters {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t precedence;
|
|
|
|
uint8_t delay;
|
|
|
|
uint8_t reliability;
|
|
|
|
uint8_t peak;
|
|
|
|
uint8_t mean;
|
|
|
|
uint8_t pdp_type;
|
2011-03-31 16:25:13 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Defined in TS 31.111 Section 8.52 */
|
2010-04-06 10:06:41 +00:00
|
|
|
struct stk_bearer_description {
|
2011-03-31 16:25:13 +00:00
|
|
|
enum stk_bearer_type type;
|
|
|
|
struct stk_gprs_bearer_parameters gprs;
|
2010-04-06 10:06:41 +00:00
|
|
|
};
|
|
|
|
|
2010-04-06 10:06:46 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.57 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs.
|
|
|
|
*/
|
|
|
|
struct stk_card_reader_id {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t id[127];
|
|
|
|
uint8_t len;
|
2010-04-06 10:06:46 +00:00
|
|
|
};
|
|
|
|
|
2010-04-06 10:06:47 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.58 the address can be either ipv4 or ipv6.
|
|
|
|
* So the maximum size is 16 (for ipv6).
|
|
|
|
*/
|
|
|
|
struct stk_other_address {
|
2010-04-14 18:10:45 +00:00
|
|
|
union {
|
|
|
|
/* Network Byte Order */
|
2010-08-25 11:00:21 +00:00
|
|
|
guint32 ipv4;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t ipv6[16];
|
2010-04-14 18:10:45 +00:00
|
|
|
} addr;
|
2010-06-11 10:39:48 +00:00
|
|
|
enum stk_address_type type;
|
2010-04-06 10:06:47 +00:00
|
|
|
};
|
|
|
|
|
2010-04-20 06:14:56 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.59 */
|
|
|
|
struct stk_uicc_te_interface {
|
2011-03-31 16:25:13 +00:00
|
|
|
enum stk_transport_protocol_type protocol;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t port;
|
2010-04-20 06:14:56 +00:00
|
|
|
};
|
|
|
|
|
2010-04-20 06:14:57 +00:00
|
|
|
/*
|
|
|
|
* Defined in TS 102.223 Section 8.60.
|
|
|
|
* According to 101.220, Section 4, aid contains two fields RID and PIX.
|
|
|
|
* RID has 5 bytes, while PIX contains information between 7 to 11 bytes.
|
|
|
|
* So the maximum size of aid is 16 bytes.
|
|
|
|
*/
|
|
|
|
struct stk_aid {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t aid[16];
|
2010-04-20 06:14:57 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-04-21 04:55:46 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.62 */
|
|
|
|
struct stk_display_parameters {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t height;
|
|
|
|
uint8_t width;
|
|
|
|
uint8_t effects;
|
2010-04-21 04:55:46 +00:00
|
|
|
};
|
|
|
|
|
2010-04-21 04:55:47 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.63 */
|
|
|
|
struct stk_service_record {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t tech_id;
|
|
|
|
uint8_t serv_id;
|
|
|
|
uint8_t *serv_rec;
|
2010-04-21 04:55:47 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-04-21 04:55:48 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.64 */
|
|
|
|
struct stk_device_filter {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t tech_id;
|
|
|
|
uint8_t *dev_filter;
|
2010-04-21 04:55:48 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-04-21 04:55:49 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.65 */
|
|
|
|
struct stk_service_search {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t tech_id;
|
|
|
|
uint8_t *ser_search;
|
2010-04-21 04:55:49 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-04-21 04:55:50 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.66 */
|
|
|
|
struct stk_attribute_info {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t tech_id;
|
|
|
|
uint8_t *attr_info;
|
2010-04-21 04:55:50 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-04-21 04:55:52 +00:00
|
|
|
/*
|
|
|
|
* According to TS 102.223 Section 8.68, remote entity address can be either
|
|
|
|
* 6-bytes IEEE-802 address, or 4-bytes IrDA device address.
|
|
|
|
*/
|
|
|
|
struct stk_remote_entity_address {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t coding_type;
|
|
|
|
bool has_address;
|
2010-04-21 04:55:52 +00:00
|
|
|
union {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t ieee802[6];
|
|
|
|
uint8_t irda[4];
|
2010-04-21 04:55:52 +00:00
|
|
|
} addr;
|
|
|
|
};
|
|
|
|
|
2010-02-27 16:19:51 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.72 the length of text attribute CTLV is 1
|
|
|
|
* byte. This means that the maximum size is 127 according to the rules
|
|
|
|
* of CTLVs. Empty attribute options will have len of 0.
|
|
|
|
*/
|
|
|
|
struct stk_text_attribute {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t attributes[127];
|
|
|
|
uint8_t len;
|
2010-02-27 16:19:51 +00:00
|
|
|
};
|
|
|
|
|
2010-06-13 09:43:21 +00:00
|
|
|
/* Defined in TS 31.111 Section 8.72 */
|
|
|
|
struct stk_pdp_act_par {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t par[127];
|
|
|
|
uint8_t len;
|
2010-06-13 09:43:21 +00:00
|
|
|
};
|
|
|
|
|
2010-04-21 04:55:56 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.73 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs. In addition,
|
|
|
|
* the length should be also the number multiplied by 4, so the maximum number
|
|
|
|
* is 124.
|
|
|
|
*/
|
|
|
|
struct stk_item_text_attribute_list {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t list[124];
|
|
|
|
uint8_t len;
|
2010-04-21 04:55:56 +00:00
|
|
|
};
|
|
|
|
|
2010-04-22 15:12:19 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.78 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum length is 127 bytes for the total length of layout and
|
|
|
|
* relative-sized frame. Thus the maximum length of relative size is 126 bytes.
|
|
|
|
*/
|
|
|
|
struct stk_frame_layout {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t layout;
|
|
|
|
uint8_t size[126];
|
2010-04-22 15:12:19 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-04-22 15:12:20 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.79 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum length is 127 bytes for the total length of default frame
|
|
|
|
* id and frame information list. Thus the maximum length of frame information
|
|
|
|
* list is 126 bytes.
|
|
|
|
*/
|
|
|
|
struct stk_frames_info {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t id;
|
2010-06-11 10:39:49 +00:00
|
|
|
struct {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t width, height;
|
2010-06-11 10:39:49 +00:00
|
|
|
} list[63];
|
2010-04-22 15:12:20 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-04-27 09:47:07 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.80 */
|
|
|
|
struct stk_frame_id {
|
2018-12-29 21:26:37 +00:00
|
|
|
bool has_id;
|
|
|
|
uint8_t id;
|
2010-04-27 09:47:07 +00:00
|
|
|
};
|
|
|
|
|
2010-04-22 15:12:22 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.82 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs.
|
|
|
|
*/
|
|
|
|
struct stk_mms_reference {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t ref[127];
|
|
|
|
uint8_t len;
|
2010-04-22 15:12:22 +00:00
|
|
|
};
|
|
|
|
|
2010-04-22 15:12:23 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.83 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs.
|
|
|
|
*/
|
|
|
|
struct stk_mms_id {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t id[127];
|
|
|
|
uint8_t len;
|
2010-04-22 15:12:23 +00:00
|
|
|
};
|
|
|
|
|
2010-04-22 15:12:24 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.84 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs.
|
|
|
|
*/
|
|
|
|
struct stk_mms_transfer_status {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t status[127];
|
|
|
|
uint8_t len;
|
2010-04-22 15:12:24 +00:00
|
|
|
};
|
|
|
|
|
2010-04-22 15:12:25 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.85 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum size is 127 according to the rules of CTLVs.
|
|
|
|
*/
|
|
|
|
struct stk_mms_content_id {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t id[127];
|
|
|
|
uint8_t len;
|
2010-04-22 15:12:25 +00:00
|
|
|
};
|
|
|
|
|
2010-04-22 15:12:28 +00:00
|
|
|
/* Defined in TS 102.223 Section 8.88 */
|
|
|
|
struct stk_registry_application_data {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t port;
|
|
|
|
uint8_t type;
|
2010-04-22 15:12:28 +00:00
|
|
|
char *name;
|
|
|
|
};
|
|
|
|
|
2010-04-22 15:12:30 +00:00
|
|
|
/*
|
|
|
|
* According to 102.223 Section 8.90 the length of CTLV is 1 byte. This means
|
|
|
|
* that the maximum length is 127 bytes for the total length of broadcast
|
|
|
|
* network technology and location information. Thus the maximum length of
|
|
|
|
* location information is 126 bytes.
|
|
|
|
*/
|
|
|
|
struct stk_broadcast_network_information {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t tech;
|
|
|
|
uint8_t loc_info[126];
|
2010-04-22 15:12:30 +00:00
|
|
|
unsigned int len;
|
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:50 +00:00
|
|
|
/* Defined in TS 131.111 Section 8.91 */
|
|
|
|
struct stk_routing_area_info {
|
|
|
|
char mnc[OFONO_MAX_MNC_LENGTH + 1];
|
|
|
|
char mcc[OFONO_MAX_MCC_LENGTH + 1];
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t lac;
|
|
|
|
uint8_t rac;
|
2010-06-11 10:39:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Defined in TS 131.111 Section 8.99 */
|
|
|
|
struct stk_tracking_area_id {
|
|
|
|
char mnc[OFONO_MAX_MNC_LENGTH + 1];
|
|
|
|
char mcc[OFONO_MAX_MCC_LENGTH + 1];
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t tac;
|
2010-06-11 10:39:50 +00:00
|
|
|
};
|
|
|
|
|
2010-02-27 16:17:22 +00:00
|
|
|
struct stk_command_display_text {
|
|
|
|
char *text;
|
2010-03-31 09:17:02 +00:00
|
|
|
struct stk_icon_id icon_id;
|
2018-12-29 21:26:37 +00:00
|
|
|
bool immediate_response;
|
2010-02-27 16:19:19 +00:00
|
|
|
struct stk_duration duration;
|
2010-05-10 10:38:46 +00:00
|
|
|
struct stk_text_attribute text_attr;
|
2010-04-27 09:47:07 +00:00
|
|
|
struct stk_frame_id frame_id;
|
2010-02-23 23:10:26 +00:00
|
|
|
};
|
|
|
|
|
2010-04-27 09:47:12 +00:00
|
|
|
struct stk_command_get_inkey {
|
|
|
|
char *text;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_duration duration;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-03-01 23:58:14 +00:00
|
|
|
struct stk_command_get_input {
|
|
|
|
char *text;
|
2010-05-10 10:38:46 +00:00
|
|
|
struct stk_response_length resp_len;
|
2010-03-01 23:58:14 +00:00
|
|
|
char *default_text;
|
2010-03-31 09:17:02 +00:00
|
|
|
struct stk_icon_id icon_id;
|
2010-05-10 10:38:46 +00:00
|
|
|
struct stk_text_attribute text_attr;
|
2010-04-27 09:47:07 +00:00
|
|
|
struct stk_frame_id frame_id;
|
2010-03-01 23:58:14 +00:00
|
|
|
};
|
|
|
|
|
2010-05-10 10:38:48 +00:00
|
|
|
struct stk_command_play_tone {
|
|
|
|
char *alpha_id;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t tone;
|
2010-05-10 10:38:48 +00:00
|
|
|
struct stk_duration duration;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-05-13 10:48:18 +00:00
|
|
|
struct stk_command_poll_interval {
|
|
|
|
struct stk_duration duration;
|
|
|
|
};
|
|
|
|
|
2010-05-13 10:48:19 +00:00
|
|
|
struct stk_command_setup_menu {
|
|
|
|
char *alpha_id;
|
2018-12-28 19:48:34 +00:00
|
|
|
struct l_queue *items;
|
2010-05-13 10:48:19 +00:00
|
|
|
struct stk_items_next_action_indicator next_act;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_item_icon_id_list item_icon_id_list;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_item_text_attribute_list item_text_attr_list;
|
|
|
|
};
|
|
|
|
|
2010-05-13 10:48:22 +00:00
|
|
|
struct stk_command_select_item {
|
|
|
|
char *alpha_id;
|
2018-12-28 19:48:34 +00:00
|
|
|
struct l_queue *items;
|
2010-05-13 10:48:22 +00:00
|
|
|
struct stk_items_next_action_indicator next_act;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t item_id;
|
2010-05-13 10:48:22 +00:00
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_item_icon_id_list item_icon_id_list;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_item_text_attribute_list item_text_attr_list;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-03-16 02:01:04 +00:00
|
|
|
struct stk_command_send_sms {
|
|
|
|
char *alpha_id;
|
|
|
|
struct sms gsm_sms;
|
2010-05-10 10:38:59 +00:00
|
|
|
struct stk_common_byte_array cdma_sms;
|
2010-03-31 09:17:02 +00:00
|
|
|
struct stk_icon_id icon_id;
|
2010-05-10 10:38:46 +00:00
|
|
|
struct stk_text_attribute text_attr;
|
2010-04-27 09:47:07 +00:00
|
|
|
struct stk_frame_id frame_id;
|
2010-03-16 02:01:04 +00:00
|
|
|
};
|
|
|
|
|
2010-06-13 09:43:11 +00:00
|
|
|
struct stk_command_send_ss {
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_ss ss;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-06-17 10:35:07 +00:00
|
|
|
struct stk_command_send_ussd {
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_ussd_string ussd_string;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-05-13 10:48:27 +00:00
|
|
|
struct stk_command_setup_call {
|
|
|
|
char *alpha_id_usr_cfm;
|
|
|
|
struct stk_address addr;
|
|
|
|
struct stk_ccp ccp;
|
|
|
|
struct stk_subaddress subaddr;
|
|
|
|
struct stk_duration duration;
|
|
|
|
struct stk_icon_id icon_id_usr_cfm;
|
|
|
|
char *alpha_id_call_setup;
|
|
|
|
struct stk_icon_id icon_id_call_setup;
|
|
|
|
struct stk_text_attribute text_attr_usr_cfm;
|
|
|
|
struct stk_text_attribute text_attr_call_setup;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-05-13 10:48:29 +00:00
|
|
|
struct stk_command_refresh {
|
2018-12-29 00:12:21 +00:00
|
|
|
struct l_queue *file_list;
|
2010-05-13 10:48:29 +00:00
|
|
|
struct stk_aid aid;
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-05-13 10:48:35 +00:00
|
|
|
struct stk_command_setup_event_list {
|
|
|
|
struct stk_event_list event_list;
|
|
|
|
};
|
|
|
|
|
2010-05-13 10:48:37 +00:00
|
|
|
struct stk_command_perform_card_apdu {
|
|
|
|
struct stk_c_apdu c_apdu;
|
|
|
|
};
|
|
|
|
|
2010-05-13 10:48:43 +00:00
|
|
|
struct stk_command_timer_mgmt {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t timer_id;
|
2010-05-13 10:48:43 +00:00
|
|
|
struct stk_timer_value timer_value;
|
|
|
|
};
|
|
|
|
|
2010-05-19 10:24:39 +00:00
|
|
|
struct stk_command_setup_idle_mode_text {
|
|
|
|
char *text;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-05-19 10:24:41 +00:00
|
|
|
struct stk_command_run_at_command {
|
|
|
|
char *alpha_id;
|
|
|
|
char *at_command;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-05-19 10:24:43 +00:00
|
|
|
struct stk_command_send_dtmf {
|
|
|
|
char *alpha_id;
|
|
|
|
char *dtmf;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-05-19 10:24:45 +00:00
|
|
|
struct stk_command_language_notification {
|
|
|
|
char language[3];
|
|
|
|
};
|
|
|
|
|
2010-05-26 14:39:08 +00:00
|
|
|
struct stk_command_launch_browser {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t browser_id;
|
2010-05-26 14:39:08 +00:00
|
|
|
char *url;
|
|
|
|
struct stk_common_byte_array bearer;
|
2018-12-29 00:12:21 +00:00
|
|
|
struct l_queue *prov_file_refs;
|
2010-05-26 14:39:08 +00:00
|
|
|
char *text_gateway_proxy_id;
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
struct stk_common_byte_array network_name;
|
|
|
|
char *text_usr;
|
|
|
|
char *text_passwd;
|
|
|
|
};
|
|
|
|
|
2011-03-31 16:25:13 +00:00
|
|
|
struct stk_command_open_channel {
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_bearer_description bearer_desc;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t buf_size;
|
2011-03-31 16:25:13 +00:00
|
|
|
char *apn;
|
|
|
|
struct stk_other_address local_addr;
|
|
|
|
char *text_usr;
|
|
|
|
char *text_passwd;
|
|
|
|
struct stk_uicc_te_interface uti;
|
|
|
|
struct stk_other_address data_dest_addr;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
2010-06-13 09:43:17 +00:00
|
|
|
struct stk_command_close_channel {
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_command_receive_data {
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_icon_id icon_id;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t data_len;
|
2010-06-13 09:43:17 +00:00
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_command_send_data {
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_common_byte_array data;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_command_service_search {
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_service_search serv_search;
|
|
|
|
struct stk_device_filter dev_filter;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_command_get_service_info {
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_attribute_info attr_info;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_command_declare_service {
|
|
|
|
struct stk_service_record serv_rec;
|
|
|
|
struct stk_uicc_te_interface intf;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_command_set_frames {
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
struct stk_frame_layout frame_layout;
|
|
|
|
struct stk_frame_id frame_id_default;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_command_retrieve_mms {
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_icon_id icon_id;
|
|
|
|
struct stk_mms_reference mms_ref;
|
2018-12-29 00:12:21 +00:00
|
|
|
struct l_queue *mms_rec_files;
|
2010-06-13 09:43:17 +00:00
|
|
|
struct stk_mms_content_id mms_content_id;
|
|
|
|
struct stk_mms_id mms_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_command_submit_mms {
|
|
|
|
char *alpha_id;
|
|
|
|
struct stk_icon_id icon_id;
|
2018-12-29 00:12:21 +00:00
|
|
|
struct l_queue *mms_subm_files;
|
2010-06-13 09:43:17 +00:00
|
|
|
struct stk_mms_id mms_id;
|
|
|
|
struct stk_text_attribute text_attr;
|
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_command_display_mms {
|
2018-12-29 00:12:21 +00:00
|
|
|
struct l_queue *mms_subm_files;
|
2010-06-13 09:43:17 +00:00
|
|
|
struct stk_mms_id mms_id;
|
2018-12-29 21:26:37 +00:00
|
|
|
bool imd_resp;
|
2010-06-13 09:43:17 +00:00
|
|
|
struct stk_frame_id frame_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_command_activate {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t actv_desc;
|
2010-06-13 09:43:17 +00:00
|
|
|
};
|
|
|
|
|
2010-06-22 11:20:44 +00:00
|
|
|
enum stk_command_parse_result {
|
|
|
|
STK_PARSE_RESULT_OK,
|
|
|
|
STK_PARSE_RESULT_TYPE_NOT_UNDERSTOOD,
|
|
|
|
STK_PARSE_RESULT_DATA_NOT_UNDERSTOOD,
|
|
|
|
STK_PARSE_RESULT_MISSING_VALUE,
|
|
|
|
};
|
|
|
|
|
2010-02-23 23:10:26 +00:00
|
|
|
struct stk_command {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t number;
|
|
|
|
uint8_t type;
|
|
|
|
uint8_t qualifier;
|
2010-02-23 23:10:26 +00:00
|
|
|
enum stk_device_identity_type src;
|
|
|
|
enum stk_device_identity_type dst;
|
2010-06-22 11:20:44 +00:00
|
|
|
enum stk_command_parse_result status;
|
2010-02-23 23:10:26 +00:00
|
|
|
|
|
|
|
union {
|
|
|
|
struct stk_command_display_text display_text;
|
2010-04-27 09:47:12 +00:00
|
|
|
struct stk_command_get_inkey get_inkey;
|
2010-03-01 23:58:14 +00:00
|
|
|
struct stk_command_get_input get_input;
|
2010-05-10 10:38:48 +00:00
|
|
|
struct stk_command_play_tone play_tone;
|
2010-05-13 10:48:18 +00:00
|
|
|
struct stk_command_poll_interval poll_interval;
|
2010-05-13 20:36:35 +00:00
|
|
|
struct stk_command_refresh refresh;
|
2010-05-13 10:48:19 +00:00
|
|
|
struct stk_command_setup_menu setup_menu;
|
2010-05-13 10:48:26 +00:00
|
|
|
struct stk_command_select_item select_item;
|
|
|
|
struct stk_command_send_sms send_sms;
|
2010-06-13 09:43:11 +00:00
|
|
|
struct stk_command_send_ss send_ss;
|
2010-06-17 10:35:07 +00:00
|
|
|
struct stk_command_send_ussd send_ussd;
|
2010-05-13 10:48:27 +00:00
|
|
|
struct stk_command_setup_call setup_call;
|
2010-05-13 10:48:35 +00:00
|
|
|
struct stk_command_setup_event_list setup_event_list;
|
2010-05-13 10:48:37 +00:00
|
|
|
struct stk_command_perform_card_apdu perform_card_apdu;
|
2010-05-13 10:48:43 +00:00
|
|
|
struct stk_command_timer_mgmt timer_mgmt;
|
2010-05-19 10:24:39 +00:00
|
|
|
struct stk_command_setup_idle_mode_text setup_idle_mode_text;
|
2010-05-19 10:24:41 +00:00
|
|
|
struct stk_command_run_at_command run_at_command;
|
2010-05-19 10:24:43 +00:00
|
|
|
struct stk_command_send_dtmf send_dtmf;
|
2010-05-19 10:24:45 +00:00
|
|
|
struct stk_command_language_notification language_notification;
|
2010-05-26 14:39:08 +00:00
|
|
|
struct stk_command_launch_browser launch_browser;
|
2011-03-31 16:25:13 +00:00
|
|
|
struct stk_command_open_channel open_channel;
|
2010-06-13 09:43:17 +00:00
|
|
|
struct stk_command_close_channel close_channel;
|
|
|
|
struct stk_command_receive_data receive_data;
|
|
|
|
struct stk_command_send_data send_data;
|
|
|
|
struct stk_command_service_search service_search;
|
|
|
|
struct stk_command_get_service_info get_service_info;
|
|
|
|
struct stk_command_declare_service declare_service;
|
|
|
|
struct stk_command_set_frames set_frames;
|
|
|
|
struct stk_command_retrieve_mms retrieve_mms;
|
|
|
|
struct stk_command_submit_mms submit_mms;
|
|
|
|
struct stk_command_display_mms display_mms;
|
|
|
|
struct stk_command_activate activate;
|
2010-02-23 23:10:26 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
void (*destructor)(struct stk_command *command);
|
|
|
|
};
|
|
|
|
|
2010-05-16 14:04:46 +00:00
|
|
|
/* TERMINAL RESPONSEs defined in TS 102.223 Section 6.8 */
|
|
|
|
struct stk_response_generic {
|
|
|
|
};
|
|
|
|
|
2010-05-16 14:05:04 +00:00
|
|
|
struct stk_answer_text {
|
|
|
|
char *text;
|
2018-12-29 21:26:37 +00:00
|
|
|
bool packed;
|
|
|
|
bool yesno;
|
2010-06-15 16:03:53 +00:00
|
|
|
/*
|
|
|
|
* If a "Yes/No" answer was requested in a GET INKEY command,
|
2010-05-16 14:05:04 +00:00
|
|
|
* .yesno must be TRUE and text should be non-NULL to indicate
|
|
|
|
* a Yes response or NULL to indicate a No response.
|
|
|
|
*/
|
|
|
|
};
|
|
|
|
|
2010-09-09 12:31:53 +00:00
|
|
|
struct stk_ussd_text {
|
2018-12-29 21:26:37 +00:00
|
|
|
bool has_text;
|
|
|
|
const uint8_t *text;
|
2010-09-09 12:31:53 +00:00
|
|
|
int dcs;
|
|
|
|
int len;
|
|
|
|
};
|
|
|
|
|
2011-03-31 16:25:13 +00:00
|
|
|
struct stk_channel {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t id;
|
2011-03-31 16:25:13 +00:00
|
|
|
enum stk_channel_status status;
|
|
|
|
};
|
|
|
|
|
2010-05-16 14:05:04 +00:00
|
|
|
struct stk_response_get_inkey {
|
|
|
|
struct stk_answer_text text;
|
|
|
|
struct stk_duration duration;
|
|
|
|
};
|
|
|
|
|
2010-05-16 14:05:21 +00:00
|
|
|
struct stk_response_get_input {
|
|
|
|
struct stk_answer_text text;
|
|
|
|
};
|
|
|
|
|
2010-05-16 14:06:17 +00:00
|
|
|
struct stk_response_poll_interval {
|
|
|
|
struct stk_duration max_interval;
|
|
|
|
};
|
|
|
|
|
2010-05-16 14:07:22 +00:00
|
|
|
struct stk_response_select_item {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t item_id;
|
2010-05-16 14:07:22 +00:00
|
|
|
};
|
|
|
|
|
2010-05-27 04:59:40 +00:00
|
|
|
struct stk_response_set_up_call {
|
|
|
|
struct stk_common_byte_array cc_requested_action;
|
|
|
|
struct {
|
2018-12-29 21:26:37 +00:00
|
|
|
bool cc_modified;
|
2010-05-27 04:59:40 +00:00
|
|
|
struct stk_result result;
|
|
|
|
} modified_result;
|
|
|
|
};
|
|
|
|
|
2010-05-27 04:59:44 +00:00
|
|
|
struct stk_response_local_info {
|
|
|
|
union {
|
|
|
|
struct stk_location_info location;
|
|
|
|
const char *imei;
|
|
|
|
struct stk_network_measurement_results {
|
|
|
|
struct stk_common_byte_array nmr;
|
2010-06-16 22:23:44 +00:00
|
|
|
struct stk_bcch_channel_list bcch_ch_list;
|
2010-05-27 04:59:44 +00:00
|
|
|
} nmr;
|
|
|
|
struct sms_scts datetime;
|
|
|
|
const char *language;
|
|
|
|
enum stk_battery_state battery_charge;
|
|
|
|
enum stk_access_technology_type access_technology;
|
2010-06-17 10:35:11 +00:00
|
|
|
struct stk_timing_advance tadv;
|
2010-05-27 04:59:44 +00:00
|
|
|
/* Bits[31:24]: manufacturer, bits[23:0]: serial number */
|
|
|
|
guint32 esn;
|
|
|
|
const char *imeisv;
|
|
|
|
enum stk_network_search_mode {
|
|
|
|
STK_NETWORK_SEARCH_MODE_MANUAL = 0x00,
|
|
|
|
STK_NETWORK_SEARCH_MODE_AUTOMATIC = 0x01,
|
|
|
|
} search_mode;
|
|
|
|
const char *meid;
|
|
|
|
struct stk_broadcast_network_information broadcast_network_info;
|
|
|
|
struct stk_access_technologies {
|
|
|
|
const enum stk_access_technology_type *techs;
|
|
|
|
int length;
|
|
|
|
} access_technologies;
|
|
|
|
struct {
|
|
|
|
struct stk_access_technologies access_techs;
|
|
|
|
struct stk_location_info *locations;
|
|
|
|
} location_infos;
|
|
|
|
struct {
|
|
|
|
struct stk_access_technologies access_techs;
|
|
|
|
struct stk_network_measurement_results *nmrs;
|
|
|
|
} nmrs;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2010-05-27 04:59:48 +00:00
|
|
|
struct stk_response_timer_mgmt {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t id;
|
2010-05-27 04:59:48 +00:00
|
|
|
struct stk_timer_value value;
|
|
|
|
};
|
|
|
|
|
2010-05-27 04:59:52 +00:00
|
|
|
struct stk_response_run_at_command {
|
|
|
|
const char *at_response;
|
|
|
|
};
|
|
|
|
|
2010-09-09 12:31:53 +00:00
|
|
|
struct stk_response_send_ussd {
|
|
|
|
struct stk_ussd_text text;
|
|
|
|
};
|
|
|
|
|
2011-03-31 16:25:13 +00:00
|
|
|
struct stk_response_open_channel {
|
|
|
|
struct stk_channel channel;
|
|
|
|
struct stk_bearer_description bearer_desc;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t buf_size;
|
2011-03-31 16:25:13 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_response_receive_data {
|
|
|
|
struct stk_common_byte_array rx_data;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t rx_remaining;
|
2011-03-31 16:25:13 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_response_send_data {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t tx_avail;
|
2011-03-31 16:25:13 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct stk_response_channel_status {
|
|
|
|
struct stk_channel channel;
|
|
|
|
};
|
|
|
|
|
2010-05-16 14:04:46 +00:00
|
|
|
struct stk_response {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t number;
|
|
|
|
uint8_t type;
|
|
|
|
uint8_t qualifier;
|
2010-05-16 14:04:46 +00:00
|
|
|
enum stk_device_identity_type src;
|
|
|
|
enum stk_device_identity_type dst;
|
|
|
|
struct stk_result result;
|
|
|
|
|
|
|
|
union {
|
|
|
|
struct stk_response_generic display_text;
|
2010-05-16 14:05:04 +00:00
|
|
|
struct stk_response_get_inkey get_inkey;
|
2010-05-16 14:05:21 +00:00
|
|
|
struct stk_response_get_input get_input;
|
2010-06-17 13:42:09 +00:00
|
|
|
struct stk_response_generic more_time;
|
2010-05-16 14:06:01 +00:00
|
|
|
struct stk_response_generic play_tone;
|
2010-05-16 14:06:17 +00:00
|
|
|
struct stk_response_poll_interval poll_interval;
|
2010-05-16 14:06:34 +00:00
|
|
|
struct stk_response_generic refresh;
|
2010-05-16 14:06:51 +00:00
|
|
|
struct stk_response_generic set_up_menu;
|
2010-05-16 14:07:22 +00:00
|
|
|
struct stk_response_select_item select_item;
|
2010-05-16 14:05:39 +00:00
|
|
|
struct stk_response_generic send_sms;
|
2010-05-27 04:59:40 +00:00
|
|
|
struct stk_response_set_up_call set_up_call;
|
2010-05-27 04:59:42 +00:00
|
|
|
struct stk_response_generic polling_off;
|
2010-05-27 04:59:44 +00:00
|
|
|
struct stk_response_local_info provide_local_info;
|
2010-05-27 04:59:46 +00:00
|
|
|
struct stk_response_generic set_up_event_list;
|
2010-05-27 04:59:48 +00:00
|
|
|
struct stk_response_timer_mgmt timer_mgmt;
|
2010-05-27 04:59:50 +00:00
|
|
|
struct stk_response_generic set_up_idle_mode_text;
|
2010-05-27 04:59:52 +00:00
|
|
|
struct stk_response_run_at_command run_at_command;
|
2010-05-27 04:59:54 +00:00
|
|
|
struct stk_response_generic send_dtmf;
|
2010-05-27 04:59:56 +00:00
|
|
|
struct stk_response_generic language_notification;
|
2010-05-27 04:59:58 +00:00
|
|
|
struct stk_response_generic launch_browser;
|
2010-09-09 12:31:53 +00:00
|
|
|
struct stk_response_send_ussd send_ussd;
|
2011-03-31 16:25:13 +00:00
|
|
|
struct stk_response_open_channel open_channel;
|
|
|
|
struct stk_response_receive_data receive_data;
|
|
|
|
struct stk_response_send_data send_data;
|
|
|
|
struct stk_response_channel_status channel_status;
|
2010-05-16 14:04:46 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
void (*destructor)(struct stk_response *response);
|
|
|
|
};
|
|
|
|
|
2010-06-07 10:08:24 +00:00
|
|
|
/* ENVELOPEs defined in TS 102.223 Section 7 */
|
|
|
|
struct stk_envelope_sms_pp_download {
|
|
|
|
struct stk_address address;
|
|
|
|
struct sms_deliver message;
|
|
|
|
};
|
|
|
|
|
2010-06-07 10:08:26 +00:00
|
|
|
struct stk_envelope_cbs_pp_download {
|
|
|
|
struct cbs page;
|
|
|
|
};
|
|
|
|
|
2010-06-07 10:08:30 +00:00
|
|
|
struct stk_envelope_menu_selection {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t item_id;
|
|
|
|
bool help_request;
|
2010-06-07 10:08:30 +00:00
|
|
|
};
|
|
|
|
|
2010-06-07 10:08:36 +00:00
|
|
|
struct stk_envelope_sms_mo_control {
|
|
|
|
struct stk_address sc_address;
|
|
|
|
struct stk_address dest_address;
|
|
|
|
struct stk_location_info location;
|
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:46 +00:00
|
|
|
enum stk_call_control_type {
|
|
|
|
STK_CC_TYPE_CALL_SETUP,
|
|
|
|
STK_CC_TYPE_SUPPLEMENTARY_SERVICE,
|
|
|
|
STK_CC_TYPE_USSD_OP,
|
|
|
|
STK_CC_TYPE_PDP_CTX_ACTIVATION,
|
|
|
|
STK_CC_TYPE_EPS_PDN_CONNECTION_ACTIVATION,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Used both in the ENVELOPE message to UICC and response from UICC */
|
|
|
|
struct stk_envelope_call_control {
|
|
|
|
enum stk_call_control_type type;
|
|
|
|
union {
|
|
|
|
struct stk_address address;
|
|
|
|
struct stk_address ss_string;
|
|
|
|
struct stk_ussd_string ussd_string;
|
|
|
|
struct stk_common_byte_array pdp_ctx_params;
|
|
|
|
struct stk_common_byte_array eps_pdn_params;
|
|
|
|
};
|
2010-06-15 16:03:53 +00:00
|
|
|
/*
|
|
|
|
* At least one of the following two fields must be present in a
|
2010-06-11 10:39:46 +00:00
|
|
|
* response indicating modification of the call.
|
2010-06-15 16:03:53 +00:00
|
|
|
* In an EVELOPE message, only allowed for a call setup.
|
|
|
|
*/
|
2010-06-11 10:39:46 +00:00
|
|
|
struct stk_ccp ccp1;
|
|
|
|
struct stk_subaddress subaddress;
|
|
|
|
struct stk_location_info location;
|
|
|
|
/* Only allowed when ccp1 is present */
|
|
|
|
struct stk_ccp ccp2;
|
|
|
|
char *alpha_id;
|
|
|
|
/* Only allowed when both ccp1 and ccp2 are present */
|
|
|
|
struct stk_bc_repeat bc_repeat;
|
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:50 +00:00
|
|
|
struct stk_envelope_event_download {
|
|
|
|
enum stk_event_type type;
|
|
|
|
union {
|
|
|
|
struct {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t transaction_id;
|
2010-06-11 10:39:50 +00:00
|
|
|
struct stk_address caller_address;
|
|
|
|
struct stk_subaddress caller_subaddress;
|
|
|
|
} mt_call;
|
|
|
|
struct {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t transaction_id;
|
2010-06-11 10:39:50 +00:00
|
|
|
} call_connected;
|
|
|
|
struct {
|
|
|
|
struct stk_transaction_id transaction_ids;
|
|
|
|
struct stk_cause cause;
|
|
|
|
} call_disconnected;
|
|
|
|
struct {
|
|
|
|
enum stk_service_state state;
|
|
|
|
/* Present when state indicated Normal Service */
|
|
|
|
struct stk_location_info info;
|
|
|
|
} location_status;
|
|
|
|
struct stk_reader_status card_reader_status;
|
|
|
|
char language_selection[3];
|
|
|
|
struct {
|
|
|
|
enum stk_browser_termination_cause cause;
|
|
|
|
} browser_termination;
|
|
|
|
struct {
|
2011-03-31 16:25:13 +00:00
|
|
|
struct stk_channel channel;
|
2018-12-29 21:26:37 +00:00
|
|
|
uint16_t channel_data_len;
|
2010-06-11 10:39:50 +00:00
|
|
|
} data_available;
|
|
|
|
struct {
|
2011-03-31 16:25:13 +00:00
|
|
|
struct stk_channel channel;
|
2010-06-11 10:39:50 +00:00
|
|
|
struct stk_bearer_description bearer_desc;
|
|
|
|
struct stk_other_address address;
|
|
|
|
} channel_status;
|
|
|
|
struct stk_access_technologies access_technology_change;
|
|
|
|
struct stk_display_parameters display_params_changed;
|
|
|
|
struct {
|
|
|
|
/*
|
|
|
|
* Note the service record subfield is not required,
|
|
|
|
* only the Technology id and Service id.
|
|
|
|
*/
|
|
|
|
struct stk_service_record service_record;
|
|
|
|
struct stk_remote_entity_address remote_addr;
|
|
|
|
struct stk_uicc_te_interface transport_level;
|
|
|
|
/* Only present if transport_level present */
|
|
|
|
struct stk_other_address transport_addr;
|
|
|
|
} local_connection;
|
|
|
|
enum stk_network_search_mode network_search_mode_change;
|
|
|
|
struct stk_common_byte_array browsing_status;
|
|
|
|
struct stk_frames_info frames_information_change;
|
|
|
|
enum stk_i_wlan_access_status i_wlan_access_status;
|
|
|
|
struct {
|
|
|
|
struct stk_location_info location;
|
|
|
|
struct stk_routing_area_info rai;
|
|
|
|
struct stk_tracking_area_id tai;
|
|
|
|
enum stk_access_technology_type access_tech;
|
|
|
|
enum stk_update_attach_type update_attach;
|
|
|
|
enum stk_rejection_cause_code cause;
|
|
|
|
} network_rejection;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:52 +00:00
|
|
|
struct stk_envelope_timer_expiration {
|
2018-12-29 21:26:37 +00:00
|
|
|
uint8_t id;
|
2010-06-11 10:39:52 +00:00
|
|
|
struct stk_timer_value value;
|
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:54 +00:00
|
|
|
struct stk_envelope_ussd_data_download {
|
|
|
|
struct stk_ussd_string string;
|
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:55 +00:00
|
|
|
struct stk_envelope_mms_transfer_status {
|
|
|
|
struct stk_file transfer_file;
|
|
|
|
struct stk_mms_id id;
|
|
|
|
struct stk_mms_transfer_status transfer_status;
|
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:56 +00:00
|
|
|
struct stk_envelope_mms_notification_download {
|
|
|
|
struct stk_common_byte_array msg;
|
2018-12-29 21:26:37 +00:00
|
|
|
bool last;
|
2010-06-11 10:39:56 +00:00
|
|
|
};
|
|
|
|
|
2010-06-11 10:39:57 +00:00
|
|
|
struct stk_envelope_terminal_apps {
|
|
|
|
struct stk_registry_application_data *list;
|
|
|
|
int count;
|
2018-12-29 21:26:37 +00:00
|
|
|
bool last;
|
2010-06-11 10:39:57 +00:00
|
|
|
};
|
|
|
|
|
2010-06-07 10:08:24 +00:00
|
|
|
struct stk_envelope {
|
|
|
|
enum stk_envelope_type type;
|
|
|
|
enum stk_device_identity_type src;
|
|
|
|
enum stk_device_identity_type dst;
|
|
|
|
union {
|
|
|
|
struct stk_envelope_sms_pp_download sms_pp_download;
|
2010-06-07 10:08:26 +00:00
|
|
|
struct stk_envelope_cbs_pp_download cbs_pp_download;
|
2010-06-07 10:08:30 +00:00
|
|
|
struct stk_envelope_menu_selection menu_selection;
|
2010-06-11 10:39:46 +00:00
|
|
|
struct stk_envelope_call_control call_control;
|
2010-06-07 10:08:36 +00:00
|
|
|
struct stk_envelope_sms_mo_control sms_mo_control;
|
2010-06-11 10:39:50 +00:00
|
|
|
struct stk_envelope_event_download event_download;
|
2010-06-11 10:39:52 +00:00
|
|
|
struct stk_envelope_timer_expiration timer_expiration;
|
2010-06-11 10:39:54 +00:00
|
|
|
struct stk_envelope_ussd_data_download ussd_data_download;
|
2010-06-11 10:39:55 +00:00
|
|
|
struct stk_envelope_mms_transfer_status mms_status;
|
2010-06-11 10:39:56 +00:00
|
|
|
struct stk_envelope_mms_notification_download mms_notification;
|
2010-06-11 10:39:57 +00:00
|
|
|
struct stk_envelope_terminal_apps terminal_apps;
|
2010-06-07 10:08:24 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2018-12-29 21:26:37 +00:00
|
|
|
struct stk_command *stk_command_new_from_pdu(const uint8_t *pdu,
|
|
|
|
unsigned int len);
|
2010-02-23 23:10:26 +00:00
|
|
|
void stk_command_free(struct stk_command *command);
|
2010-05-16 14:04:46 +00:00
|
|
|
|
2018-12-29 21:26:37 +00:00
|
|
|
const uint8_t *stk_pdu_from_response(const struct stk_response *response,
|
2010-06-07 10:08:23 +00:00
|
|
|
unsigned int *out_length);
|
2018-12-29 21:26:37 +00:00
|
|
|
const uint8_t *stk_pdu_from_envelope(const struct stk_envelope *envelope,
|
2010-06-07 10:08:24 +00:00
|
|
|
unsigned int *out_length);
|
2018-12-29 21:26:37 +00:00
|
|
|
char *stk_text_to_html(const char *text, const uint16_t *attrs, int num_attrs);
|
|
|
|
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);
|