3 * oFono - Open Source Telephony
5 * Copyright (C) 2008-2011 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
31 #include <ofono/types.h>
37 struct sim_eons_operator_info *pnn_list;
43 struct spdi_operator {
44 char mcc[OFONO_MAX_MCC_LENGTH + 1];
45 char mnc[OFONO_MAX_MNC_LENGTH + 1];
49 char mcc[OFONO_MAX_MCC_LENGTH + 1];
50 char mnc[OFONO_MAX_MNC_LENGTH + 1];
72 static struct sim_ef_info ef_db[] = {
73 { 0x2F05, ROOTMF, ROOTMF, EF, BINARY, 0, ALW, PIN },
74 { 0x2FE2, ROOTMF, ROOTMF, EF, BINARY, 10, ALW, NEV },
75 { 0x4F20, 0x5F50, 0x5F50, EF, BINARY, 0, PIN, ADM },
76 { 0x5F50, 0x7F10, 0x7F10, DF, 0, 0, PIN, ADM },
77 { 0x6F05, 0x7F20, 0x7FFF, EF, BINARY, 0, ALW, PIN },
78 { 0x6F07, 0x7F20, 0x7FFF, EF, BINARY, 9, PIN, ADM },
79 { 0x6F11, 0x7F20, 0x7FFF, EF, BINARY, 0, PIN, PIN },
80 { 0x6F13, 0x7F20, 0x7FFF, EF, BINARY, 0, PIN, PIN },
81 { 0x6F14, 0x7F20, 0x7FFF, EF, BINARY, 0, PIN, ADM },
82 { 0x6F15, 0x7F20, 0x7FFF, EF, BINARY, 0, PIN, PIN },
83 { 0x6F16, 0x7F20, 0x7FFF, EF, BINARY, 0, PIN, ADM },
84 { 0x6F17, 0x7F20, 0x7FFF, EF, RECORD, 0, PIN, PIN },
85 { 0x6F18, 0x7F20, 0x7FFF, EF, BINARY, 10, PIN, ADM },
86 { 0x6F19, 0x7F20, 0x7FFF, EF, RECORD, 0, PIN, PIN },
87 { 0x6F38, 0x7F20, 0x7FFF, EF, BINARY, 0, PIN, ADM },
88 { 0x6F3A, 0x7F10, 0x7F10, EF, RECORD, 0, PIN, PIN },
89 { 0x6F3B, 0x7F10, 0x7FFF, EF, RECORD, 0, PIN, PIN2 },
90 { 0x6F40, 0x7F10, 0x7FFF, EF, RECORD, 0, PIN, PIN },
91 { 0x6F45, 0x7F20, 0x7FFF, EF, BINARY, 0, PIN, PIN },
92 { 0x6F46, 0x7F20, 0x7FFF, EF, BINARY, 17, ALW, ADM },
93 { 0x6F48, 0x7F20, 0x7FFF, EF, BINARY, 0, PIN, ADM },
94 { 0x6F49, 0x7F10, 0x7FFF, EF, RECORD, 0, PIN, ADM },
95 { 0x6F4D, 0x7F20, 0x7FFF, EF, RECORD, 0, PIN, PIN2 },
96 { 0x6F50, 0x7F20, 0x7FFF, EF, BINARY, 0, PIN, PIN },
97 { 0x6F56, 0x0000, 0x7FFF, EF, BINARY, 0, PIN, PIN2 },
98 { 0x6FAD, 0x7F20, 0x7FFF, EF, BINARY, 0, ALW, ADM },
99 { 0x6FAE, 0x7F20, 0x0000, EF, BINARY, 1, ALW, ADM },
100 { 0x6FB7, 0x7F20, 0x7FFF, EF, BINARY, 0, ALW, ADM },
101 { 0x6FC5, 0x7F20, 0x7FFF, EF, RECORD, 0, ALW, ADM },
102 { 0x6FC6, 0x7F20, 0x7FFF, EF, RECORD, 0, ALW, ADM },
103 { 0x6FC7, 0x7F20, 0x7FFF, EF, RECORD, 0, PIN, PIN },
104 { 0x6FC9, 0x7F20, 0x7FFF, EF, RECORD, 0, PIN, PIN },
105 { 0x6FCA, 0x7F20, 0x7FFF, EF, RECORD, 0, PIN, PIN },
106 { 0x6FCB, 0x7F20, 0x7FFF, EF, RECORD, 16, PIN, PIN },
107 { 0x6FCD, 0x7F20, 0x7FFF, EF, BINARY, 0, PIN, ADM },
108 { 0x6FDE, 0x7F20, 0x7FFF, EF, BINARY, 0, ALW, ADM },
109 { 0x7F10, ROOTMF, ROOTMF, DF, 0, 0, 0, 0 },
110 { 0x7F20, ROOTMF, ROOTMF, DF, 0, 0, 0, 0 },
111 { 0x7FFF, 0x0000, ROOTMF, DF, 0, 0, 0, 0 }
114 void simple_tlv_iter_init(struct simple_tlv_iter *iter,
115 const unsigned char *pdu, unsigned int len)
125 gboolean simple_tlv_iter_next(struct simple_tlv_iter *iter)
127 const unsigned char *pdu = iter->pdu + iter->pos;
128 const unsigned char *end = iter->pdu + iter->max;
139 * ISO 7816-4, Section 5.2.1:
141 * The tag field consists of a single byte encoding a tag number from
142 * 1 to 254. The values 00 and FF are invalid for tag fields.
144 * The length field consists of one or three consecutive bytes.
145 * - If the first byte is not set to FF, then the length field
146 * consists of a single byte encoding a number from zero to
148 * - If the first byte is set to FF, then the length field
149 * continues on the subsequent two bytes with any value
150 * encoding a number from zero to 65535 and denoted N
152 * If N is zero, there is no value field, i.e. data object is empty.
163 len = (pdu[0] << 8) | pdu[1];
175 iter->pos = pdu + len - iter->pdu;
180 unsigned char simple_tlv_iter_get_tag(struct simple_tlv_iter *iter)
185 unsigned short simple_tlv_iter_get_length(struct simple_tlv_iter *iter)
190 const unsigned char *simple_tlv_iter_get_data(struct simple_tlv_iter *iter)
195 void comprehension_tlv_iter_init(struct comprehension_tlv_iter *iter,
196 const unsigned char *pdu,
207 /* Comprehension TLVs defined in Section 7 of ETSI TS 101.220 */
208 gboolean comprehension_tlv_iter_next(struct comprehension_tlv_iter *iter)
210 const unsigned char *pdu = iter->pdu + iter->pos;
211 const unsigned char *end = iter->pdu + iter->max;
219 if (*pdu == 0x00 || *pdu == 0xFF || *pdu == 0x80)
222 cr = bit_field(*pdu, 7, 1);
223 tag = bit_field(*pdu, 0, 7);
227 * ETSI TS 101.220, Section 7.1.1.2
229 * If byte 1 of the tag is equal to 0x7F, then the tag is encoded
230 * on the following two bytes, with bit 8 of the 2nd byte of the tag
237 cr = bit_field(pdu[0], 7, 1);
238 tag = ((pdu[0] & 0x7f) << 8) | pdu[1];
240 if (tag < 0x0001 || tag > 0x7fff)
252 unsigned int extended_bytes = len - 0x80;
255 if (extended_bytes == 0 || extended_bytes > 3)
258 if ((pdu + extended_bytes) > end)
264 for (len = 0, i = 0; i < extended_bytes; i++)
265 len = (len << 8) | *pdu++;
276 iter->pos = pdu + len - iter->pdu;
281 unsigned short comprehension_tlv_iter_get_tag(
282 struct comprehension_tlv_iter *iter)
287 gboolean comprehension_tlv_get_cr(struct comprehension_tlv_iter *iter)
292 unsigned int comprehension_tlv_iter_get_length(
293 struct comprehension_tlv_iter *iter)
298 const unsigned char *comprehension_tlv_iter_get_data(
299 struct comprehension_tlv_iter *iter)
304 void comprehension_tlv_iter_copy(struct comprehension_tlv_iter *from,
305 struct comprehension_tlv_iter *to)
313 to->data = from->data;
316 void ber_tlv_iter_init(struct ber_tlv_iter *iter, const unsigned char *pdu,
324 unsigned int ber_tlv_iter_get_tag(struct ber_tlv_iter *iter)
329 enum ber_tlv_data_type ber_tlv_iter_get_class(struct ber_tlv_iter *iter)
334 enum ber_tlv_data_encoding_type
335 ber_tlv_iter_get_encoding(struct ber_tlv_iter *iter)
337 return iter->encoding;
340 unsigned char ber_tlv_iter_get_short_tag(struct ber_tlv_iter *iter)
345 return iter->tag | (iter->encoding << 5) | (iter->class << 6);
348 unsigned int ber_tlv_iter_get_length(struct ber_tlv_iter *iter)
353 const unsigned char *ber_tlv_iter_get_data(struct ber_tlv_iter *iter)
358 /* BER TLV structure is defined in ISO/IEC 7816-4 */
359 gboolean ber_tlv_iter_next(struct ber_tlv_iter *iter)
361 const unsigned char *pdu = iter->pdu + iter->pos;
362 const unsigned char *end = iter->pdu + iter->max;
365 enum ber_tlv_data_type class;
366 enum ber_tlv_data_encoding_type encoding;
368 while ((pdu < end) && (*pdu == 0x00 || *pdu == 0xff))
374 class = bit_field(*pdu, 6, 2);
375 encoding = bit_field(*pdu, 5, 1);
376 tag = bit_field(*pdu, 0, 5);
381 * ISO 7816-4, Section 5.2.2.1:
382 * "If bits 5 to 1 of the first byte of the tag are not
383 * all set to 1, then they encode a tag number from zero
384 * to thirty and the tag field consists of a single byte.
386 * Otherwise, the tag field continues on one or more
388 * - Bit 8 of each subsequent byte shall be set to 1,
389 * unless it is the last subsequent byte
390 * - Bits 7 to 1 of the first subsequent byte shall not be
392 * - Bits 7 to 1 of the first subsequent byte, followed by
393 * bits 7 to 1 of each further subsequent byte, up to
394 * and including bits 7 to 1 of the last subsequent
395 * byte encode a tag number.
401 /* First byte of the extended tag cannot contain 0 */
402 if ((*pdu & 0x7f) == 0)
407 while ((pdu < end) && (*pdu & 0x80)) {
408 tag = (tag << 7) | (*pdu & 0x7f);
415 tag = (tag << 7) | *pdu;
425 unsigned int extended_bytes = len - 0x80;
428 if (extended_bytes == 0 || extended_bytes > 4)
431 if ((pdu + extended_bytes) > end)
437 for (len = 0, i = 0; i < extended_bytes; i++)
438 len = (len << 8) | *pdu++;
446 iter->encoding = encoding;
450 iter->pos = pdu + len - iter->pdu;
455 void ber_tlv_iter_recurse(struct ber_tlv_iter *iter,
456 struct ber_tlv_iter *recurse)
458 recurse->pdu = iter->data;
459 recurse->max = iter->len;
463 void ber_tlv_iter_recurse_simple(struct ber_tlv_iter *iter,
464 struct simple_tlv_iter *container)
466 simple_tlv_iter_init(container, iter->data, iter->len);
469 void ber_tlv_iter_recurse_comprehension(struct ber_tlv_iter *iter,
470 struct comprehension_tlv_iter *recurse)
472 comprehension_tlv_iter_init(recurse, iter->data, iter->len);
475 static const guint8 *ber_tlv_find_by_tag(const guint8 *pdu, guint8 in_tag,
476 int in_len, int *out_len)
478 struct ber_tlv_iter iter;
480 ber_tlv_iter_init(&iter, pdu, in_len);
482 while (ber_tlv_iter_next(&iter)) {
483 if (ber_tlv_iter_get_short_tag(&iter) != in_tag)
487 *out_len = ber_tlv_iter_get_length(&iter);
489 return ber_tlv_iter_get_data(&iter);
495 #define MAX_BER_TLV_HEADER 8
497 gboolean ber_tlv_builder_init(struct ber_tlv_builder *builder,
498 unsigned char *pdu, unsigned int size)
500 if (size < MAX_BER_TLV_HEADER)
506 builder->parent = NULL;
513 #define BTLV_LEN_FIELD_SIZE_NEEDED(a) \
516 ((a) <= 0xffff ? 3 : \
517 ((a) <= 0xffffff ? 4 : 5))))
519 #define BTLV_TAG_FIELD_SIZE_NEEDED(a) \
521 ((a) <= 0x7f ? 2 : 3))
523 static void ber_tlv_builder_write_header(struct ber_tlv_builder *builder)
525 int tag_size = BTLV_TAG_FIELD_SIZE_NEEDED(builder->tag);
526 int len_size = BTLV_LEN_FIELD_SIZE_NEEDED(builder->len);
527 int offset = MAX_BER_TLV_HEADER - tag_size - len_size;
528 unsigned char *pdu = builder->pdu + builder->pos;
530 /* Pad with stuff bytes */
531 memset(pdu, 0xff, offset);
534 pdu[offset++] = (builder->class << 6) |
535 (builder->encoding << 5) |
536 (tag_size == 1 ? builder->tag : 0x1f);
539 pdu[offset++] = 0x80 | (builder->tag >> 7);
542 pdu[offset++] = builder->tag & 0x7f;
544 /* Write the length */
548 pdu[offset++] = 0x80 + len_size - 1;
550 for (i = len_size - 2; i >= 0; i--)
551 pdu[offset++] = (builder->len >> (i * 8)) & 0xff;
553 pdu[offset++] = builder->len;
556 gboolean ber_tlv_builder_next(struct ber_tlv_builder *builder,
557 enum ber_tlv_data_type class,
558 enum ber_tlv_data_encoding_type encoding,
559 unsigned int new_tag)
561 if (builder->tag != 0xff) {
562 ber_tlv_builder_write_header(builder);
563 builder->pos += MAX_BER_TLV_HEADER + builder->len;
566 if (ber_tlv_builder_set_length(builder, 0) == FALSE)
569 builder->class = class;
570 builder->encoding = encoding;
571 builder->tag = new_tag;
577 * Resize the TLV because the content of Value field needs more space.
578 * If this TLV is part of another TLV, resize that one too.
580 gboolean ber_tlv_builder_set_length(struct ber_tlv_builder *builder,
581 unsigned int new_len)
583 unsigned int new_pos = builder->pos + MAX_BER_TLV_HEADER + new_len;
585 if (new_pos > builder->max)
589 ber_tlv_builder_set_length(builder->parent, new_pos);
591 builder->len = new_len;
596 unsigned char *ber_tlv_builder_get_data(struct ber_tlv_builder *builder)
598 return builder->pdu + builder->pos + MAX_BER_TLV_HEADER;
601 gboolean ber_tlv_builder_recurse(struct ber_tlv_builder *builder,
602 struct ber_tlv_builder *recurse)
604 unsigned char *end = builder->pdu + builder->max;
605 unsigned char *data = ber_tlv_builder_get_data(builder);
607 if (ber_tlv_builder_init(recurse, data, end - data) == FALSE)
610 recurse->parent = builder;
615 gboolean ber_tlv_builder_recurse_comprehension(struct ber_tlv_builder *builder,
616 struct comprehension_tlv_builder *recurse)
618 unsigned char *end = builder->pdu + builder->max;
619 unsigned char *data = ber_tlv_builder_get_data(builder);
621 if (comprehension_tlv_builder_init(recurse, data, end - data) == FALSE)
624 recurse->parent = builder;
629 void ber_tlv_builder_optimize(struct ber_tlv_builder *builder,
630 unsigned char **out_pdu, unsigned int *out_len)
635 ber_tlv_builder_write_header(builder);
637 len = builder->pos + MAX_BER_TLV_HEADER + builder->len;
639 for (pdu = builder->pdu; *pdu == 0xff; pdu++)
649 gboolean comprehension_tlv_builder_init(
650 struct comprehension_tlv_builder *builder,
651 unsigned char *pdu, unsigned int size)
659 builder->parent = NULL;
667 #define CTLV_TAG_FIELD_SIZE(a) \
668 bit_field((a), 0, 7) == 0x7f ? 3 : 1 \
670 #define CTLV_LEN_FIELD_SIZE(a) \
671 (a) >= 0x80 ? (a) - 0x7f : 1 \
673 gboolean comprehension_tlv_builder_next(
674 struct comprehension_tlv_builder *builder,
675 gboolean cr, unsigned short tag)
677 unsigned char *tlv = builder->pdu + builder->pos;
678 unsigned int prev_size = 0;
679 unsigned int new_size;
681 /* Tag is invalid when we start, means we've just been inited */
683 unsigned int tag_size = CTLV_TAG_FIELD_SIZE(tlv[0]);
684 prev_size = builder->len + tag_size;
685 prev_size += CTLV_LEN_FIELD_SIZE(tlv[tag_size]);
688 new_size = (tag < 0x7f ? 1 : 3) + 1;
690 if (builder->pos + prev_size + new_size > builder->max)
693 builder->pos += prev_size;
696 builder->pdu[builder->pos + 0] = 0x7f;
697 builder->pdu[builder->pos + 1] = (cr ? 0x80 : 0) | (tag >> 8);
698 builder->pdu[builder->pos + 2] = tag & 0xff;
700 builder->pdu[builder->pos + 0] = (cr ? 0x80 : 0x00) | tag;
703 builder->pdu[builder->pos + new_size - 1] = 0; /* Length */
709 * Resize the TLV because the content of Value field needs more space.
710 * If this TLV is part of another TLV, resize that one too.
712 gboolean comprehension_tlv_builder_set_length(
713 struct comprehension_tlv_builder *builder,
714 unsigned int new_len)
716 unsigned char *tlv = builder->pdu + builder->pos;
717 unsigned int tag_size = CTLV_TAG_FIELD_SIZE(tlv[0]);
718 unsigned int len_size, new_len_size;
719 unsigned int new_ctlv_len;
722 len_size = CTLV_LEN_FIELD_SIZE(tlv[tag_size]);
723 new_len_size = BTLV_LEN_FIELD_SIZE_NEEDED(new_len);
724 new_ctlv_len = tag_size + new_len_size + new_len;
726 /* Check there is enough space */
727 if (builder->pos + new_ctlv_len > builder->max)
731 ber_tlv_builder_set_length(builder->parent,
732 builder->pos + new_ctlv_len);
734 len = MIN(builder->len, new_len);
735 if (len > 0 && new_len_size != len_size)
736 memmove(tlv + tag_size + new_len_size,
737 tlv + tag_size + len_size, len);
739 builder->len = new_len;
741 /* Write new length */
742 if (new_len_size > 1) {
744 unsigned int offset = tag_size;
746 tlv[offset++] = 0x80 + new_len_size - 1;
748 for (i = new_len_size - 2; i >= 0; i--)
749 tlv[offset++] = (builder->len >> (i * 8)) & 0xff;
751 tlv[tag_size] = builder->len;
756 unsigned char *comprehension_tlv_builder_get_data(
757 struct comprehension_tlv_builder *builder)
759 unsigned char *tlv = builder->pdu + builder->pos;
760 unsigned int tag_size = CTLV_TAG_FIELD_SIZE(*tlv);
761 unsigned int len_size = CTLV_LEN_FIELD_SIZE(tlv[tag_size]);
763 return tlv + tag_size + len_size;
766 static char *sim_network_name_parse(const unsigned char *buffer, int length,
782 * "The MS should add the letters for the Country's Initials and a
783 * separator (e.g. a space)"
785 if (is_bit_set(dcs, 4))
788 switch (dcs & (7 << 4)) {
790 endp = memchr(buffer, 0xff, length);
792 length = endp - buffer;
793 ret = convert_gsm_to_utf8(buffer, length,
797 if ((length % 2) == 1) {
798 if (buffer[length - 1] != 0xff)
804 for (i = 0; i < length; i += 2)
805 if (buffer[i] == 0xff && buffer[i + 1] == 0xff)
808 ret = g_convert((const char *) buffer, length,
809 "UTF-8//TRANSLIT", "UCS-2BE",
820 void sim_parse_mcc_mnc(const guint8 *bcd, char *mcc, char *mnc)
822 static const char digit_lut[] = "0123456789*#abd\0";
825 digit = (bcd[0] >> 0) & 0xf;
826 *mcc++ = digit_lut[digit];
828 digit = (bcd[0] >> 4) & 0xf;
829 *mcc++ = digit_lut[digit];
831 digit = (bcd[1] >> 0) & 0xf;
832 *mcc++ = digit_lut[digit];
834 digit = (bcd[2] >> 0) & 0xf;
835 *mnc++ = digit_lut[digit];
837 digit = (bcd[2] >> 4) & 0xf;
838 *mnc++ = digit_lut[digit];
840 digit = (bcd[1] >> 4) & 0xf;
841 *mnc++ = digit_lut[digit];
844 static inline int to_semi_oct(char in)
886 void sim_encode_mcc_mnc(guint8 *out, const char *mcc, const char *mnc)
888 out[0] = to_semi_oct(mcc[0]);
889 out[0] |= to_semi_oct(mcc[1]) << 4;
891 out[1] = mcc[2] ? to_semi_oct(mcc[2]) : 0xf;
892 out[1] |= (mnc[2] ? to_semi_oct(mnc[2]) : 0xf) << 4;
894 out[2] = to_semi_oct(mnc[0]);
895 out[2] |= to_semi_oct(mnc[1]) << 4;
898 static gint spdi_operator_compare(gconstpointer a, gconstpointer b)
900 const struct spdi_operator *opa = a;
901 const struct spdi_operator *opb = b;
902 gint r = strcmp(opa->mcc, opb->mcc);
907 return strcmp(opa->mnc, opb->mnc);
914 struct sim_spdi *sim_spdi_new(const guint8 *tlv, int length)
916 const guint8 *plmn_list_tlv;
917 const guint8 *plmn_list;
918 struct sim_spdi *spdi;
919 struct spdi_operator *oper;
926 plmn_list_tlv = ber_tlv_find_by_tag(tlv, 0xA3, length, &tlv_length);
928 if (plmn_list_tlv == NULL)
931 plmn_list = ber_tlv_find_by_tag(plmn_list_tlv, 0x80, tlv_length,
934 if (plmn_list == NULL)
937 spdi = g_new0(struct sim_spdi, 1);
939 for (list_length /= 3; list_length--; plmn_list += 3) {
940 if ((plmn_list[0] & plmn_list[1] & plmn_list[2]) == 0xff)
943 oper = g_new0(struct spdi_operator, 1);
945 sim_parse_mcc_mnc(plmn_list, oper->mcc, oper->mnc);
946 spdi->operators = g_slist_insert_sorted(spdi->operators, oper,
947 spdi_operator_compare);
953 gboolean sim_spdi_lookup(struct sim_spdi *spdi,
954 const char *mcc, const char *mnc)
956 struct spdi_operator spdi_op;
961 g_strlcpy(spdi_op.mcc, mcc, sizeof(spdi_op.mcc));
962 g_strlcpy(spdi_op.mnc, mnc, sizeof(spdi_op.mnc));
964 return g_slist_find_custom(spdi->operators, &spdi_op,
965 spdi_operator_compare) != NULL;
968 void sim_spdi_free(struct sim_spdi *spdi)
973 g_slist_foreach(spdi->operators, (GFunc)g_free, NULL);
974 g_slist_free(spdi->operators);
978 static void pnn_operator_free(struct sim_eons_operator_info *oper)
984 g_free(oper->shortname);
985 g_free(oper->longname);
988 struct sim_eons *sim_eons_new(int pnn_records)
990 struct sim_eons *eons = g_new0(struct sim_eons, 1);
992 eons->pnn_list = g_new0(struct sim_eons_operator_info, pnn_records);
993 eons->pnn_max = pnn_records;
998 gboolean sim_eons_pnn_is_empty(struct sim_eons *eons)
1000 return !eons->pnn_valid;
1003 void sim_eons_add_pnn_record(struct sim_eons *eons, int record,
1004 const guint8 *tlv, int length)
1006 const unsigned char *name;
1008 struct sim_eons_operator_info *oper = &eons->pnn_list[record-1];
1010 name = ber_tlv_find_by_tag(tlv, 0x43, length, &namelength);
1012 if (name == NULL || !namelength)
1015 oper->longname = sim_network_name_parse(name, namelength,
1018 name = ber_tlv_find_by_tag(tlv, 0x45, length, &namelength);
1020 if (name && namelength)
1021 oper->shortname = sim_network_name_parse(name, namelength,
1024 name = ber_tlv_find_by_tag(tlv, 0x80, length, &namelength);
1026 if (name && namelength)
1027 oper->info = sim_string_to_utf8(name, namelength);
1029 eons->pnn_valid = TRUE;
1032 static struct opl_operator *opl_operator_alloc(const guint8 *record)
1034 struct opl_operator *oper = g_new0(struct opl_operator, 1);
1036 sim_parse_mcc_mnc(record, oper->mcc, oper->mnc);
1039 oper->lac_tac_low = (record[0] << 8) | record[1];
1041 oper->lac_tac_high = (record[0] << 8) | record[1];
1044 oper->id = record[0];
1049 void sim_eons_add_opl_record(struct sim_eons *eons,
1050 const guint8 *contents, int length)
1052 struct opl_operator *oper;
1054 oper = opl_operator_alloc(contents);
1056 if (oper->id > eons->pnn_max) {
1061 eons->opl_list = g_slist_prepend(eons->opl_list, oper);
1064 void sim_eons_optimize(struct sim_eons *eons)
1066 eons->opl_list = g_slist_reverse(eons->opl_list);
1069 void sim_eons_free(struct sim_eons *eons)
1076 for (i = 0; i < eons->pnn_max; i++)
1077 pnn_operator_free(eons->pnn_list + i);
1079 g_free(eons->pnn_list);
1081 g_slist_foreach(eons->opl_list, (GFunc)g_free, NULL);
1082 g_slist_free(eons->opl_list);
1087 static const struct sim_eons_operator_info *
1088 sim_eons_lookup_common(struct sim_eons *eons,
1089 const char *mcc, const char *mnc,
1090 gboolean have_lac, guint16 lac)
1093 const struct opl_operator *opl;
1096 for (l = eons->opl_list; l; l = l->next) {
1099 for (i = 0; i < OFONO_MAX_MCC_LENGTH; i++)
1100 if (mcc[i] != opl->mcc[i] &&
1101 !(opl->mcc[i] == 'b' && mcc[i]))
1103 if (i < OFONO_MAX_MCC_LENGTH)
1106 for (i = 0; i < OFONO_MAX_MNC_LENGTH; i++)
1107 if (mnc[i] != opl->mnc[i] &&
1108 !(opl->mnc[i] == 'b' && mnc[i]))
1110 if (i < OFONO_MAX_MNC_LENGTH)
1113 if (opl->lac_tac_low == 0 && opl->lac_tac_high == 0xfffe)
1116 if (have_lac == FALSE)
1119 if ((lac >= opl->lac_tac_low) && (lac <= opl->lac_tac_high))
1128 /* 0 is not a valid record id */
1132 return &eons->pnn_list[opl->id - 1];
1135 const struct sim_eons_operator_info *sim_eons_lookup(struct sim_eons *eons,
1139 return sim_eons_lookup_common(eons, mcc, mnc, FALSE, 0);
1142 const struct sim_eons_operator_info *sim_eons_lookup_with_lac(
1143 struct sim_eons *eons,
1148 return sim_eons_lookup_common(eons, mcc, mnc, TRUE, lac);
1152 * Extract extended BCD format defined in 3GPP 11.11, 31.102. The format
1153 * is different from what is defined in 3GPP 24.008 and 23.040 (sms).
1155 * Here the digits with values 'C', 'D' and 'E' are treated differently,
1156 * for more details see 31.102 Table 4.4
1158 * 'C' - DTMF Control Digit Separator, represented as 'c' by this function
1159 * 'D' - Wild Value, represented as a '?' by this function
1160 * 'E' - RFU, used to be used as a Shift Operator in 11.11
1163 * Note that a second or subsequent 'C' BCD value will be interpreted as a
1166 void sim_extract_bcd_number(const unsigned char *buf, int len, char *out)
1168 static const char digit_lut[] = "0123456789*#c?e\0";
1172 for (i = 0; i < len; i++) {
1175 out[i*2] = digit_lut[oct & 0x0f];
1176 out[i*2+1] = digit_lut[(oct & 0xf0) >> 4];
1182 void sim_encode_bcd_number(const char *number, unsigned char *out)
1184 while (number[0] != '\0' && number[1] != '\0') {
1185 *out = to_semi_oct(*number++);
1186 *out++ |= to_semi_oct(*number++) << 4;
1190 *out = to_semi_oct(*number) | 0xf0;
1193 gboolean sim_adn_parse(const unsigned char *data, int length,
1194 struct ofono_phone_number *ph, char **identifier)
1198 const unsigned char *alpha;
1205 alpha_length = length - 14;
1207 data += alpha_length;
1209 number_len = *data++;
1212 if (number_len > 11 || ton_npi == 0xff)
1217 /* BCD coded, however the TON/NPI is given by the first byte */
1219 sim_extract_bcd_number(data, number_len, ph->number);
1221 if (identifier == NULL)
1224 /* Alpha-Identifier field */
1225 if (alpha_length > 0)
1226 *identifier = sim_string_to_utf8(alpha, alpha_length);
1233 void sim_adn_build(unsigned char *data, int length,
1234 const struct ofono_phone_number *ph,
1235 const char *identifier)
1237 int number_len = strlen(ph->number);
1238 unsigned char *alpha = NULL;
1239 int alpha_written = 0;
1242 alpha_length = length - 14;
1244 /* Alpha-Identifier field */
1245 if (alpha_length > 0) {
1247 alpha = utf8_to_sim_string(identifier, alpha_length,
1250 memcpy(data, alpha, alpha_written);
1254 memset(data + alpha_written, 0xff,
1255 alpha_length - alpha_written);
1256 data += alpha_length;
1259 number_len = (number_len + 1) / 2;
1260 *data++ = number_len + 1;
1263 sim_encode_bcd_number(ph->number, data);
1264 memset(data + number_len, 0xff, 10 - number_len);
1273 static int find_ef_by_id(const void *key, const void *value)
1275 unsigned short id = GPOINTER_TO_UINT(key);
1276 const struct sim_ef_info *info = value;
1278 return id - info->id;
1281 struct sim_ef_info *sim_ef_db_lookup(unsigned short id)
1283 struct sim_ef_info *result;
1284 unsigned int nelem = sizeof(ef_db) / sizeof(struct sim_ef_info);
1286 result = bsearch(GUINT_TO_POINTER((unsigned int) id), ef_db, nelem,
1287 sizeof(struct sim_ef_info), find_ef_by_id);
1292 unsigned int sim_ef_db_get_path_2g(unsigned short id, unsigned char out_path[])
1294 struct sim_ef_info *info;
1295 unsigned int nelem = sizeof(ef_db) / sizeof(struct sim_ef_info);
1296 unsigned char path[6];
1300 info = bsearch(GUINT_TO_POINTER((unsigned int) id), ef_db, nelem,
1301 sizeof(struct sim_ef_info), find_ef_by_id);
1305 path[i++] = info->parent2g & 0xff;
1306 path[i++] = info->parent2g >> 8;
1308 while (info->parent2g != ROOTMF) {
1309 info = bsearch(GUINT_TO_POINTER((unsigned int) info->parent2g),
1310 ef_db, nelem, sizeof(struct sim_ef_info),
1315 path[i++] = info->parent2g & 0xff;
1316 path[i++] = info->parent2g >> 8;
1319 for (j = 0; j < i; j++)
1320 out_path[j] = path[i - j - 1];
1325 unsigned int sim_ef_db_get_path_3g(unsigned short id, unsigned char out_path[])
1327 struct sim_ef_info *info;
1328 unsigned int nelem = sizeof(ef_db) / sizeof(struct sim_ef_info);
1329 unsigned char path[6];
1333 info = bsearch(GUINT_TO_POINTER((unsigned int) id), ef_db, nelem,
1334 sizeof(struct sim_ef_info), find_ef_by_id);
1338 path[i++] = info->parent3g & 0xff;
1339 path[i++] = info->parent3g >> 8;
1341 while (info->parent3g != ROOTMF) {
1342 info = bsearch(GUINT_TO_POINTER((unsigned int) info->parent3g),
1343 ef_db, nelem, sizeof(struct sim_ef_info),
1348 path[i++] = info->parent3g & 0xff;
1349 path[i++] = info->parent3g >> 8;
1352 for (j = 0; j < i; j++)
1353 out_path[j] = path[i - j - 1];
1358 gboolean sim_parse_3g_get_response(const unsigned char *data, int len,
1359 int *file_len, int *record_len,
1360 int *structure, unsigned char *access,
1361 unsigned short *efid)
1363 const unsigned char *fcp;
1365 const unsigned char *tlv;
1368 int flen, rlen, str;
1370 unsigned char acc[3];
1371 struct sim_ef_info *info;
1373 fcp = ber_tlv_find_by_tag(data, 0x62, len, &fcp_length);
1379 * Find the file size tag 0x80 according to
1380 * ETSI 102.221 Section 11.1.1.3.2
1382 tlv = ber_tlv_find_by_tag(fcp, 0x80, fcp_length, &tlv_length);
1384 if (tlv == NULL || tlv_length < 2)
1388 for (i = 1; i < tlv_length; i++)
1389 flen = (flen << 8) | tlv[i];
1391 tlv = ber_tlv_find_by_tag(fcp, 0x83, fcp_length, &tlv_length);
1393 if (tlv == NULL || tlv_length != 2)
1396 id = (tlv[0] << 8) | tlv[1];
1398 tlv = ber_tlv_find_by_tag(fcp, 0x82, fcp_length, &tlv_length);
1400 if (tlv == NULL || (tlv_length != 2 && tlv_length != 5))
1406 switch (tlv[0] & 0x3) {
1407 case 1: /* Transparent */
1410 case 2: /* Linear Fixed */
1413 case 6: /* Cyclic */
1420 /* For cyclic or linear fixed we need record size & num records */
1421 if (str != 0x00 && tlv_length != 5)
1425 * strictly speaking the record length is 16 bit, but the valid
1426 * range is 0x01 to 0xFF according to 102.221
1434 * The 3G response data contains references to EFarr which actually
1435 * contains the security attributes. These are usually not carried
1436 * along with the response data unlike in 2G. Instead of querying
1437 * this, we simply look it up in our database. We fudge it somewhat
1438 * and guess if the file isn't found.
1440 info = sim_ef_db_lookup(id);
1452 acc[0] = (info->perm_read << 4) | info->perm_update;
1467 memcpy(access, acc, 3);
1472 gboolean sim_parse_2g_get_response(const unsigned char *response, int len,
1473 int *file_len, int *record_len,
1474 int *structure, unsigned char *access,
1475 unsigned char *file_status)
1477 if (len < 14 || response[6] != 0x04)
1480 if ((response[13] == 0x01 || response[13] == 0x03) && len < 15)
1483 *file_len = (response[2] << 8) | response[3];
1484 *structure = response[13];
1486 access[0] = response[8];
1487 access[1] = response[9];
1488 access[2] = response[10];
1490 *file_status = response[11];
1492 if (response[13] == 0x01 || response[13] == 0x03)
1493 *record_len = response[14];
1500 gboolean sim_ust_is_available(unsigned char *efust, unsigned char len,
1501 enum sim_ust_service index)
1503 if (index >= len * 8u)
1506 return (efust[index / 8] >> (index % 8)) & 1;
1509 gboolean sim_est_is_active(unsigned char *efest, unsigned char len,
1510 enum sim_est_service index)
1512 if (index >= len * 8u)
1515 return (efest[index / 8] >> (index % 8)) & 1;
1518 gboolean sim_sst_is_available(unsigned char *efsst, unsigned char len,
1519 enum sim_sst_service index)
1521 if (index >= len * 4u)
1524 return (efsst[index / 4] >> ((index % 4) * 2)) & 1;
1527 gboolean sim_sst_is_active(unsigned char *efsst, unsigned char len,
1528 enum sim_sst_service index)
1530 if (index >= len * 4u)
1533 return (efsst[index / 4] >> (((index % 4) * 2) + 1)) & 1;
1536 gboolean sim_cphs_is_active(unsigned char *cphs, enum sim_cphs_service index)
1538 if (index >= 2 * 4u)
1541 return ((cphs[index / 4] >> ((index % 4) * 2)) & 3) == 3;
1544 GSList *sim_parse_app_template_entries(const unsigned char *buffer, int len)
1547 const unsigned char *dataobj;
1550 /* Find all the application entries */
1551 while ((dataobj = ber_tlv_find_by_tag(buffer, 0x61, len,
1552 &dataobj_len)) != NULL) {
1553 struct sim_app_record app;
1554 const unsigned char *aid, *label;
1557 /* Find the aid (mandatory) */
1558 aid = ber_tlv_find_by_tag(dataobj, 0x4f, dataobj_len,
1560 if (!aid || app.aid_len < 0x01 || app.aid_len > 0x10)
1563 memcpy(app.aid, aid, app.aid_len);
1565 /* Find the label (optional) */
1566 label = ber_tlv_find_by_tag(dataobj, 0x50, dataobj_len,
1570 * Label field uses the extra complicated
1571 * encoding in 102.221 Annex A
1573 app.label = sim_string_to_utf8(label, label_len);
1575 if (app.label == NULL)
1580 ret = g_slist_prepend(ret, g_memdup(&app, sizeof(app)));
1582 len -= (dataobj - buffer) + dataobj_len;
1583 buffer = dataobj + dataobj_len;
1591 struct sim_app_record *app = ret->data;