/* Copyright (C) 2007-2008 The Android Open Source Project
**
** This software is licensed under the terms of the GNU General Public
** License version 2, as published by the Free Software Foundation, and
** may be copied, distributed, and modified under those terms.
**
** 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.
*/
#include "gsm.h"
#include <stdlib.h>
#include <string.h>
/** UTILITIES
**/
byte_t
gsm_int_to_bcdi( int value )
{
return (byte_t)((value / 10) | ((value % 10) << 4));
}
int
gsm_int_from_bcdi( byte_t val )
{
int ret = 0;
if ((val & 0xf0) <= 0x90)
ret = (val >> 4);
if ((val & 0x0f) <= 0x90)
ret |= (val % 0xf)*10;
return ret;
}
#if 0
static int
gsm_bcdi_to_ascii( cbytes_t bcd, int bcdlen, bytes_t dst )
{
static byte_t bcdichars[14] = "0123456789*#,N";
int result = 0;
int shift = 0;
while (bcdlen > 0) {
int c = (bcd[0] >> shift) & 0xf;
if (c == 0xf && bcdlen == 1)
break;
if (c < 14) {
if (dst) dst[result] = bcdichars[c];
result += 1;
}
bcdlen --;
shift += 4;
if (shift == 8) {
bcd++;
shift = 0;
}
}
return result;
}
#endif
#if 0
static int
gsm_bcdi_from_ascii( cbytes_t ascii, int asciilen, bytes_t dst )
{
cbytes_t end = ascii + asciilen;
int result = 0;
int phase = 0x01;
while (ascii < end) {
int c = *ascii++;
if (c == '*')
c = 11;
else if (c == '#')
c = 12;
else if (c == ',')
c = 13;
else if (c == 'N')
c = 14;
else {
c -= '0';
if ((unsigned)c >= 10)
break;
}
phase = (phase << 4) | c;
if (phase & 0x100) {
if (dst) dst[result] = (byte_t) phase;
result += 1;
phase = 0x01;
}
}
if (phase != 0x01) {
if (dst) dst[result] = (byte_t)( phase | 0xf0 );
result += 1;
}
return result;
}
#endif
int
gsm_hexchar_to_int( char c )
{
if ((unsigned)(c - '0') < 10)
return c - '0';
if ((unsigned)(c - 'a') < 6)
return 10 + (c - 'a');
if ((unsigned)(c - 'A') < 6)
return 10 + (c - 'A');
return -1;
}
int
gsm_hexchar_to_int0( char c )
{
int ret = gsm_hexchar_to_int(c);
return (ret < 0) ? 0 : ret;
}
int
gsm_hex2_to_byte( const char* hex )
{
int hi = gsm_hexchar_to_int(hex[0]);
int lo = gsm_hexchar_to_int(hex[1]);
if (hi < 0 || lo < 0)
return -1;
return ( (hi << 4) | lo );
}
int
gsm_hex4_to_short( const char* hex )
{
int hi = gsm_hex2_to_byte(hex);
int lo = gsm_hex2_to_byte(hex+2);
if (hi < 0 || lo < 0)
return -1;
return ((hi << 8) | lo);
}
int
gsm_hex2_to_byte0( const char* hex )
{
int hi = gsm_hexchar_to_int0(hex[0]);
int lo = gsm_hexchar_to_int0(hex[1]);
return (byte_t)( (hi << 4) | lo );
}
void
gsm_hex_from_byte( char* hex, int val )
{
static const char hexdigits[] = "0123456789abcdef";
hex[0] = hexdigits[(val >> 4) & 15];
hex[1] = hexdigits[val & 15];
}
void
gsm_hex_from_short( char* hex, int val )
{
gsm_hex_from_byte( hex, (val >> 8) );
gsm_hex_from_byte( hex+2, val );
}
/** HEX
**/
void
gsm_hex_to_bytes0( cbytes_t hex, int hexlen, bytes_t dst )
{
int nn;
for (nn = 0; nn < hexlen/2; nn++ ) {
dst[nn] = (byte_t) gsm_hex2_to_byte0( (const char*)hex+2*nn );
}
if (hexlen & 1) {
dst[nn] = gsm_hexchar_to_int0( hex[2*nn] ) << 4;
}
}
int
gsm_hex_to_bytes( cbytes_t hex, int hexlen, bytes_t dst )
{
int nn;
if (hexlen & 1) /* must be even */
return -1;
for (nn = 0; nn < hexlen/2; nn++ ) {
int c = gsm_hex2_to_byte( (const char*)hex+2*nn );
if (c < 0) return -1;
dst[nn] = (byte_t) c;
}
return hexlen/2;
}
void
gsm_hex_from_bytes( char* hex, cbytes_t src, int srclen )
{
int nn;
for (nn = 0; nn < srclen; nn++) {
gsm_hex_from_byte( hex + 2*nn, src[nn] );
}
}
/** ROPES
**/
void
gsm_rope_init( GsmRope rope )
{
rope->data = NULL;
rope->pos = 0;
rope->max = 0;
rope->error = 0;
}
void
gsm_rope_init_alloc( GsmRope rope, int count )
{
rope->data = rope->data0;
rope->pos = 0;
rope->max = sizeof(rope->data0);
rope->error = 0;
if (count > 0) {
rope->data = calloc( count, 1 );
rope->max = count;
if (rope->data == NULL) {
rope->error = 1;
rope->max = 0;
}
}
}
int
gsm_rope_done( GsmRope rope )
{
int result = rope->error;
if (rope->data && rope->data != rope->data0)
free(rope->data);
rope->data = NULL;
rope->pos = 0;
rope->max = 0;
rope->error = 0;
return result;
}
bytes_t
gsm_rope_done_acquire( GsmRope rope, int *psize )
{
bytes_t result = rope->data;
*psize = rope->pos;
if (result == rope->data0) {
result = malloc( rope->pos );
if (result != NULL)
memcpy( result, rope->data, rope->pos );
}
return result;
}
int
gsm_rope_ensure( GsmRope rope, int new_count )
{
if (rope->data != NULL) {
int old_max = rope->max;
bytes_t old_data = rope->data == rope->data0 ? NULL : rope->data;
int new_max = old_max;
bytes_t new_data;
while (new_max < new_count) {
new_max += (new_max >> 1) + 4;
}
new_data = realloc( old_data, new_max );
if (new_data == NULL) {
rope->error = 1;
return -1;
}
rope->data = new_data;
rope->max = new_max;
} else {
rope->max = new_count;
}
return 0;
}
static int
gsm_rope_can_grow( GsmRope rope, int count )
{
if (!rope->data || rope->error)
return 0;
if (rope->pos + count > rope->max)
{
if (rope->data == NULL)
rope->max = rope->pos + count;
else if (rope->error ||
gsm_rope_ensure( rope, rope->pos + count ) < 0)
return 0;
}
return 1;
}
void
gsm_rope_add_c( GsmRope rope, char c )
{
if (gsm_rope_can_grow(rope, 1)) {
rope->data[ rope->pos ] = (byte_t) c;
}
rope->pos += 1;
}
void
gsm_rope_add( GsmRope rope, const void* buf, int buflen )
{
if (gsm_rope_can_grow(rope, buflen)) {
memcpy( rope->data + rope->pos, (const char*)buf, buflen );
}
rope->pos += buflen;
}
void*
gsm_rope_reserve( GsmRope rope, int count )
{
void* result = NULL;
if (gsm_rope_can_grow(rope, count))
{
if (rope->data != NULL)
result = rope->data + rope->pos;
}
rope->pos += count;
return result;
}
/* skip a given number of Unicode characters in a utf-8 byte string */
cbytes_t
utf8_skip( cbytes_t utf8,
cbytes_t utf8end,
int count)
{
cbytes_t p = utf8;
cbytes_t end = utf8end;
for ( ; count > 0; count-- ) {
int c;
if (p >= end)
break;
c = *p++;
if (c > 128) {
while (p < end && (p[0] & 0xc0) == 0x80)
p++;
}
}
return p;
}
static __inline__ int
utf8_next( cbytes_t *pp, cbytes_t end )
{
cbytes_t p = *pp;
int result = -1;
if (p < end) {
int c= *p++;
if (c >= 128) {
if ((c & 0xe0) == 0xc0)
c &= 0x1f;
else if ((c & 0xf0) == 0xe0)
c &= 0x0f;
else
c &= 0x07;
while (p < end && (p[0] & 0xc0) == 0x80) {
c = (c << 6) | (p[0] & 0x3f);
p ++;
}
}
result = c;
*pp = p;
}
return result;
}
__inline__ int
utf8_write( bytes_t utf8, int offset, int v )
{
int result;
if (v < 128) {
result = 1;
if (utf8)
utf8[offset] = (byte_t) v;
} else if (v < 0x800) {
result = 2;
if (utf8) {
utf8[offset+0] = (byte_t)( 0xc0 | (v >> 6) );
utf8[offset+1] = (byte_t)( 0x80 | (v & 0x3f) );
}
} else if (v < 0x10000) {
result = 3;
if (utf8) {
utf8[offset+0] = (byte_t)( 0xe0 | (v >> 12) );
utf8[offset+1] = (byte_t)( 0x80 | ((v >> 6) & 0x3f) );
utf8[offset+2] = (byte_t)( 0x80 | (v & 0x3f) );
}
} else {
result = 4;
if (utf8) {
utf8[offset+0] = (byte_t)( 0xf0 | ((v >> 18) & 0x7) );
utf8[offset+1] = (byte_t)( 0x80 | ((v >> 12) & 0x3f) );
utf8[offset+2] = (byte_t)( 0x80 | ((v >> 6) & 0x3f) );
utf8[offset+3] = (byte_t)( 0x80 | (v & 0x3f) );
}
}
return result;
}
static __inline__ int
ucs2_write( bytes_t ucs2, int offset, int v )
{
if (ucs2) {
ucs2[offset+0] = (byte_t) (v >> 8);
ucs2[offset+1] = (byte_t) (v);
}
return 2;
}
int
utf8_check( cbytes_t p, int utf8len )
{
cbytes_t end = p + utf8len;
int result = 0;
if (p) {
while (p < end) {
int c = *p++;
if (c >= 128) {
int len;
if ((c & 0xe0) == 0xc0) {
len = 1;
}
else if ((c & 0xf0) == 0xe0) {
len = 2;
}
else if ((c & 0xf8) == 0xf0) {
len = 3;
}
else
goto Exit; /* malformed utf-8 */
if (p+len > end) /* string too short */
goto Exit;
for ( ; len > 0; len--, p++ ) {
if ((p[0] & 0xc0) != 0x80)
goto Exit;
}
}
}
result = 1;
}
Exit:
return result;
}
/** UCS2 to UTF8
**/
/* convert a UCS2 string into a UTF8 byte string, assumes 'buf' is correctly sized */
int
ucs2_to_utf8( cbytes_t ucs2,
int ucs2len,
bytes_t buf )
{
int nn;
int result = 0;
for (nn = 0; nn < ucs2len; ucs2 += 2, nn++) {
int c= (ucs2[0] << 8) | ucs2[1];
result += utf8_write(buf, result, c);
}
return result;
}
/* count the number of UCS2 chars contained in a utf8 byte string */
int
utf8_to_ucs2( cbytes_t utf8,
int utf8len,
bytes_t ucs2 )
{
cbytes_t p = utf8;
cbytes_t end = p + utf8len;
int result = 0;
while (p < end) {
int c = utf8_next(&p, end);
if (c < 0)
break;
result += ucs2_write(ucs2, result, c);
}
return result/2;
}
/** GSM ALPHABET
**/
#define GSM_7BITS_ESCAPE 0x1b
#define GSM_7BITS_UNKNOWN 0
static const unsigned short gsm7bits_to_unicode[128] = {
'@', 0xa3, '$', 0xa5, 0xe8, 0xe9, 0xf9, 0xec, 0xf2, 0xc7, '\n', 0xd8, 0xf8, '\r', 0xc5, 0xe5,
0x394, '_',0x3a6,0x393,0x39b,0x3a9,0x3a0,0x3a8,0x3a3,0x398,0x39e, 0, 0xc6, 0xe6, 0xdf, 0xc9,
' ', '!', '"', '#', 0xa4, '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?',
0xa1, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 0xc4, 0xd6,0x147, 0xdc, 0xa7,
0xbf, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 0xe4, 0xf6, 0xf1, 0xfc, 0xe0,
};
static const unsigned short gsm7bits_extend_to_unicode[128] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\f', 0, 0, 0, 0, 0,
0, 0, 0, 0, '^', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, '{', '}', 0, 0, 0, 0, 0,'\\',
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '[', '~', ']', 0,
'|', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0,0x20ac, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
static int
unichar_to_gsm7( int unicode )
{
int nn;
for (nn = 0; nn < 128; nn++) {
if (gsm7bits_to_unicode[nn] == unicode) {
return nn;
}
}
return -1;
}
static int
unichar_to_gsm7_extend( int unichar )
{
int nn;
for (nn = 0; nn < 128; nn++) {
if (gsm7bits_extend_to_unicode[nn] == unichar) {
return nn;
}
}
return -1;
}
/* return the number of septets needed to encode a unicode charcode */
static int
unichar_to_gsm7_count( int unicode )
{
int nn;
nn = unichar_to_gsm7(unicode);
if (nn >= 0)
return 1;
nn = unichar_to_gsm7_extend(unicode);
if (nn >= 0)
return 2;
return 0;
}
cbytes_t
utf8_skip_gsm7( cbytes_t utf8, cbytes_t utf8end, int gsm7len )
{
cbytes_t p = utf8;
cbytes_t end = utf8end;
while (gsm7len >0) {
cbytes_t q = p;
int c = utf8_next( &q, end );
int len;
if (c < 0)
break;
len = unichar_to_gsm7_count( c );
if (len == 0) /* unknown chars are replaced by spaces */
len = 1;
if (len > gsm7len)
break;
gsm7len -= len;
p = q;
}
return p;
}
int
utf8_check_gsm7( cbytes_t utf8,
int utf8len )
{
cbytes_t utf8end = utf8 + utf8len;
while (utf8 < utf8end) {
int c = utf8_next( &utf8, utf8end );
if (unichar_to_gsm7_count(c) == 0)
return 0;
}
return 1;
}
int
utf8_from_gsm7( cbytes_t src,
int septet_offset,
int septet_count,
bytes_t utf8 )
{
int shift = (septet_offset & 7);
int escaped = 0;
int result = 0;
src += (septet_offset >> 3);
for ( ; septet_count > 0; septet_count-- )
{
int c = (src[0] >> shift) & 0x7f;
int v;
if (shift > 1) {
c = ((src[1] << (8-shift)) | c) & 0x7f;
}
if (escaped) {
v = gsm7bits_extend_to_unicode[c];
} else if (c == GSM_7BITS_ESCAPE) {
escaped = 1;
goto NextSeptet;
} else {
v = gsm7bits_to_unicode[c];
}
result += utf8_write( utf8, result, v );
NextSeptet:
shift += 7;
if (shift >= 8) {
shift -= 8;
src += 1;
}
}
return result;
}
int
utf8_from_gsm8( cbytes_t src, int count, bytes_t utf8 )
{
int result = 0;
int escaped = 0;
for ( ; count > 0; count-- )
{
int c = *src++;
if (c == 0xff)
break;
if (c == GSM_7BITS_ESCAPE) {
if (escaped) { /* two escape characters => one space */
c = 0x20;
escaped = 0;
} else {
escaped = 1;
continue;
}
}
else
{
if (c >= 0x80) {
c = 0x20;
escaped = 0;
} else if (escaped) {
c = gsm7bits_extend_to_unicode[c];
} else
c = gsm7bits_to_unicode[c];
}
result += utf8_write( utf8, result, c );
}
return result;
}
/* convert a GSM 7-bit message into a unicode character array
* the 'dst' array must contain at least 160 chars. the function
* returns the number of characters decoded
*
* assumes the 'dst' array has at least septet_count items, returns the
* number of unichars really written
*/
int
ucs2_from_gsm7( bytes_t ucs2,
cbytes_t src,
int septet_offset,
int septet_count )
{
const unsigned char* p = src + (septet_offset >> 3);
int shift = (septet_offset & 7);
int escaped = 0;
int result = 0;
for ( ; septet_count > 0; septet_count-- )
{
unsigned val = (p[0] >> shift) & 0x7f;
if (shift > 1)
val = (val | (p[1] << (8-shift))) & 0x7f;
if (escaped) {
int c = gsm7bits_to_unicode[val];
result += ucs2_write(ucs2, result, c);
escaped = 0;
}
else if (val == GSM_7BITS_ESCAPE) {
escaped = 1;
}
else {
val = gsm7bits_extend_to_unicode[val];
if (val == 0)
val = 0x20;
result += ucs2_write( ucs2, result, val );
}
}
return result/2;
}
/* count the number of septets required to write a utf8 string */
static int
utf8_to_gsm7_count( cbytes_t utf8, int utf8len )
{
cbytes_t utf8end = utf8 + utf8len;
int result = 0;
while ( utf8 < utf8end ) {
int len;
int c = utf8_next( &utf8, utf8end );
if (c < 0)
break;
len = unichar_to_gsm7_count(c);
if (len == 0) /* replace non-representables with space */
len = 1;
result += len;
}
return result;
}
typedef struct {
bytes_t dst;
unsigned pad;
int bits;
int offset;
} BWriterRec, *BWriter;
static void
bwriter_init( BWriter writer, bytes_t dst, int start )
{
int shift = start & 7;
writer->dst = dst + (start >> 3);
writer->pad = 0;
writer->bits = shift;
writer->offset = start;
if (shift > 0) {
writer->pad = writer->dst[0] & ~(0xFF << shift);
}
}
static void
bwriter_add7( BWriter writer, unsigned value )
{
writer->pad |= (unsigned)(value << writer->bits);
writer->bits += 7;
if (writer->bits >= 8) {
writer->dst[0] = (byte_t)writer->pad;
writer->bits -= 8;
writer->pad >>= 8;
writer->dst += 1;
}
writer->offset += 7;
}
static int
bwriter_done( BWriter writer )
{
if (writer->bits > 0) {
writer->dst[0] = (byte_t)writer->pad;
writer->pad = 0;
writer->bits = 0;
writer->dst += 1;
}
return writer->offset;
}
/* convert a utf8 string to a gsm7 byte string - return the number of septets written */
int
utf8_to_gsm7( cbytes_t utf8, int utf8len, bytes_t dst, int offset )
{
const unsigned char* utf8end = utf8 + utf8len;
BWriterRec writer[1];
if (dst == NULL)
return utf8_to_gsm7_count(utf8, utf8len);
bwriter_init( writer, dst, offset );
while ( utf8 < utf8end ) {
int c = utf8_next( &utf8, utf8end );
int nn;
if (c < 0)
break;
nn = unichar_to_gsm7(c);
if (nn >= 0) {
bwriter_add7( writer, nn );
continue;
}
nn = unichar_to_gsm7_extend(c);
if (nn >= 0) {
bwriter_add7( writer, GSM_7BITS_ESCAPE );
bwriter_add7( writer, nn );
continue;
}
/* unknown => replaced by space */
bwriter_add7( writer, 0x20 );
}
return bwriter_done( writer );
}
int
utf8_to_gsm8( cbytes_t utf8, int utf8len, bytes_t dst )
{
const unsigned char* utf8end = utf8 + utf8len;
int result = 0;
while ( utf8 < utf8end ) {
int c = utf8_next( &utf8, utf8end );
int nn;
if (c < 0)
break;
nn = unichar_to_gsm7(c);
if (nn >= 0) {
if (dst)
dst[result] = (byte_t)nn;
result += 1;
continue;
}
nn = unichar_to_gsm7_extend(c);
if (nn >= 0) {
if (dst) {
dst[result+0] = (byte_t) GSM_7BITS_ESCAPE;
dst[result+1] = (byte_t) nn;
}
result += 2;
continue;
}
/* unknown => space */
if (dst)
dst[result] = 0x20;
result += 1;
}
return result;
}
int
ucs2_to_gsm7( cbytes_t ucs2, int ucs2len, bytes_t dst, int offset )
{
const unsigned char* ucs2end = ucs2 + ucs2len*2;
BWriterRec writer[1];
bwriter_init( writer, dst, offset );
while ( ucs2 < ucs2end ) {
int c = *ucs2++;
int nn;
for (nn = 0; nn < 128; nn++) {
if ( gsm7bits_to_unicode[nn] == c ) {
bwriter_add7( writer, nn );
goto NextUnicode;
}
}
for (nn = 0; nn < 128; nn++) {
if ( gsm7bits_extend_to_unicode[nn] == c ) {
bwriter_add7( writer, GSM_7BITS_ESCAPE );
bwriter_add7( writer, nn );
goto NextUnicode;
}
}
/* unknown */
bwriter_add7( writer, 0x20 );
NextUnicode:
;
}
return bwriter_done( writer );
}
int
ucs2_to_gsm8( cbytes_t ucs2, int ucs2len, bytes_t dst )
{
const unsigned char* ucs2end = ucs2 + ucs2len*2;
bytes_t dst0 = dst;
while ( ucs2 < ucs2end ) {
int c = *ucs2++;
int nn;
for (nn = 0; nn < 128; nn++) {
if ( gsm7bits_to_unicode[nn] == c ) {
*dst++ = (byte_t)nn;
goto NextUnicode;
}
}
for (nn = 0; nn < 128; nn++) {
if ( gsm7bits_extend_to_unicode[nn] == c ) {
dst[0] = (byte_t) GSM_7BITS_ESCAPE;
dst[1] = (byte_t) nn;
dst += 2;
goto NextUnicode;
}
}
/* unknown */
*dst++ = 0x20;
NextUnicode:
;
}
return (dst - dst0);
}
int
gsm_bcdnum_to_ascii( cbytes_t bcd, int count, bytes_t dst )
{
int result = 0;
int shift = 0;
while (count > 0) {
int c = (bcd[0] >> shift) & 0xf;
if (c == 15 && count == 1) /* ignore trailing 0xf */
break;
if (c >= 14)
c = 0;
if (dst) dst[result] = "0123456789*#,N"[c];
result += 1;
shift += 4;
if (shift == 8) {
shift = 0;
bcd += 1;
}
}
return result;
}
int
gsm_bcdnum_from_ascii( cbytes_t ascii, int asciilen, bytes_t dst )
{
cbytes_t end = ascii + asciilen;
int result = 0;
int phase = 0x01;
while (ascii < end) {
int c = *ascii++;
if (c == '*')
c = 10;
else if (c == '#')
c = 11;
else if (c == ',')
c = 12;
else if (c == 'N')
c = 13;
else {
c -= '0';
if ((unsigned)c >= 10U)
return -1;
}
phase = (phase << 4) | c;
result += 1;
if (phase & 0x100) {
if (dst) dst[result/2] = (byte_t) phase;
phase = 0x01;
}
}
if (result & 1) {
if (dst) dst[result/2] = (byte_t)(phase | 0xf0);
}
return result;
}
/** ADN: Abbreviated Dialing Number
**/
#define ADN_FOOTER_SIZE 14
#define ADN_OFFSET_NUMBER_LENGTH 0
#define ADN_OFFSET_TON_NPI 1
#define ADN_OFFSET_NUMBER_START 2
#define ADN_OFFSET_NUMBER_END 11
#define ADN_OFFSET_CAPABILITY_ID 12
#define ADN_OFFSET_EXTENSION_ID 13
/* see 10.5.1 of 3GPP 51.011 */
static int
sim_adn_alpha_to_utf8( cbytes_t alpha, cbytes_t end, bytes_t dst )
{
int result = 0;
/* ignore trailing 0xff */
while (alpha < end && end[-1] == 0xff)
end--;
if (alpha >= end)
return 0;
if (alpha[0] == 0x80) { /* UCS/2 source encoding */
alpha += 1;
result = ucs2_to_utf8( alpha, (end-alpha)/2, dst );
}
else
{
int is_ucs2 = 0;
int len = 0, base = 0;
if (alpha+3 <= end && alpha[0] == 0x81) {
is_ucs2 = 1;
len = alpha[1];
base = alpha[2] << 7;
alpha += 3;
if (len > end-alpha)
len = end-alpha;
} else if (alpha+4 <= end && alpha[0] == 0x82) {
is_ucs2 = 1;
len = alpha[1];
base = (alpha[2] << 8) | alpha[3];
alpha += 4;
if (len > end-alpha)
len = end-alpha;
}
if (is_ucs2) {
end = alpha + len;
while (alpha < end) {
int c = alpha[0];
if (c >= 0x80) {
result += utf8_write(dst, result, base + (c & 0x7f));
alpha += 1;
} else {
/* GSM character set */
int count;
for (count = 0; alpha+count < end && alpha[count] < 128; count++)
;
result += utf8_from_gsm8(alpha, count, (dst ? dst+result : NULL));
alpha += count;
}
}
}
else {
result = utf8_from_gsm8(alpha, end-alpha, dst);
}
}
return result;
}
#if 0
static int
sim_adn_alpha_from_utf8( cbytes_t utf8, int utf8len, bytes_t dst )
{
int result = 0;
if (utf8_check_gsm7(utf8, utf8len)) {
/* GSM 7-bit compatible, encode directly as 8-bit string */
result = utf8_to_gsm8(utf8, utf8len, dst);
} else {
/* otherwise, simply try UCS-2 encoding, nothing more serious at the moment */
if (dst) {
dst[0] = 0x80;
}
result = 1 + utf8_to_ucs2(utf8, utf8len, dst ? (dst+1) : NULL)*2;
}
return result;
}
#endif
int
sim_adn_record_from_bytes( SimAdnRecord rec, cbytes_t data, int len )
{
cbytes_t end = data + len;
cbytes_t footer = end - ADN_FOOTER_SIZE;
int num_len;
rec->adn.alpha[0] = 0;
rec->adn.number[0] = 0;
rec->ext_record = 0xff;
if (len < ADN_FOOTER_SIZE)
return -1;
/* alpha is optional */
if (len > ADN_FOOTER_SIZE) {
cbytes_t dataend = data + len - ADN_FOOTER_SIZE;
int count = sim_adn_alpha_to_utf8(data, dataend, NULL);
if (count > sizeof(rec->adn.alpha)-1) /* too long */
return -1;
sim_adn_alpha_to_utf8(data, dataend, rec->adn.alpha);
rec->adn.alpha[count] = 0;
}
num_len = footer[ADN_OFFSET_NUMBER_LENGTH];
if (num_len > 11)
return -1;
/* decode TON and number to ASCII, NOTE: this is lossy !! */
{
int ton = footer[ADN_OFFSET_TON_NPI];
bytes_t number = (bytes_t) rec->adn.number;
int len = sizeof(rec->adn.number)-1;
int count;
if (ton != 0x81 && ton != 0x91)
return -1;
if (ton == 0x91) {
*number++ = '+';
len -= 1;
}
count = gsm_bcdnum_to_ascii( footer + ADN_OFFSET_NUMBER_START,
num_len*2, number );
number[count] = 0;
}
return 0;
}
int
sim_adn_record_to_bytes( SimAdnRecord rec, bytes_t data, int datalen )
{
bytes_t end = data + datalen;
bytes_t footer = end - ADN_FOOTER_SIZE;
int ton = 0x81;
cbytes_t number = (cbytes_t) rec->adn.number;
if (number[0] == '+') {
ton = 0x91;
number += 1;
}
footer[0] = (strlen((const char*)number)+1)/2 + 1;
/* XXXX: TODO */
return 0;
}