426 lines
12 KiB
C
426 lines
12 KiB
C
//////////////////////////////////////////////////
|
|
//Title : wxc_netfunc.c
|
|
//Auhtor : Liu Wei
|
|
//Desc : wxc2 network convert function
|
|
//Created : 2007-06-20
|
|
//Revision :
|
|
//
|
|
//Revision :
|
|
//
|
|
//////////////////////////////////////////////////
|
|
|
|
#include "./include/pub_wnet.h"
|
|
|
|
u8 GetBcdStr ( char *str, u8 * bcd, u8 bcd_len )
|
|
{
|
|
u8 ii = 0;
|
|
|
|
Bcd2Str ( str, bcd, bcd_len * 2 );
|
|
for ( ii = 0; ii < bcd_len * 2; ii++ )
|
|
{
|
|
if( str[ii] == 'e' || str[ii] == 'E' )
|
|
break;
|
|
}
|
|
str[ii] = '\0';
|
|
return ii;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : ImsiNToA
|
|
// Function: transfer IMSI format from normal to anti sequence
|
|
// Note : 0460022157127001 --> 64002251177200f1
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void ImsiNtoA( u8 *pAntiImsi , u8 *pNormalImsi )
|
|
{
|
|
u8 ii;
|
|
u8 aa, bb = 0;
|
|
|
|
for ( ii = 1; ii <= IMSI_LEN * 2; ii++ )
|
|
{
|
|
if ( ( ii % 2 ) == 1 )
|
|
{
|
|
bb = pNormalImsi[ii / 2] & 0x0f;
|
|
}
|
|
else
|
|
{
|
|
aa = (ii == IMSI_LEN * 2) ? 0x0f0 : (pNormalImsi[ii / 2] & 0x0f0);
|
|
pAntiImsi[ii / 2 - 1] = aa | bb;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : ImsiAToN
|
|
// Function: transfer IMSI format from anti to normal sequence
|
|
// Note : 64002251177200f1 --> 0460022157127001
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void ImsiAToN ( u8 * pNormalImsi, u8 * pAntiImsi )
|
|
{ // the IMSI must 15 digits
|
|
u8 ii;
|
|
u8 aa, bb = 0;
|
|
|
|
pNormalImsi[0] = 0;
|
|
for ( ii = 0; ii < IMSI_LEN * 2; ii++ )
|
|
{
|
|
if ( ( ii % 2 ) == 1 )
|
|
{
|
|
aa = pAntiImsi[ii / 2] & 0x0f;
|
|
pNormalImsi[ii / 2] |= aa;
|
|
}
|
|
else
|
|
{
|
|
if ( ii / 2 != IMSI_LEN - 1 )
|
|
{
|
|
bb = pAntiImsi[ii / 2] & 0x0f0;
|
|
pNormalImsi[ii / 2 + 1] = bb;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : ImsiNToS
|
|
// Function: transfer IMSI format from normal to ascii string
|
|
// Note : 0460022157127001 --> "460022157127001"
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
void ImsiNToS ( u8 * pImsiStr, u8 * pNormalImsi )
|
|
{
|
|
u8 len;
|
|
u8 ii, jj;
|
|
|
|
pImsiStr[0] = ( pNormalImsi[0] & 0x0f ) + '0';
|
|
len = 1;
|
|
for ( ii = 1; ii < IMSI_LEN; ii++ )
|
|
{
|
|
jj = ( pNormalImsi[ii] >> 4 ) & 0x0f;
|
|
pImsiStr[len++] = jj + '0';
|
|
jj = pNormalImsi[ii] & 0x0f;
|
|
pImsiStr[len++] = jj + '0';
|
|
}
|
|
pImsiStr[len] = '\0';
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : ImsiSToN
|
|
// Function: transfer IMSI format from ascii string to normal
|
|
// Note : "460022157127001" --> 0460022157127001
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
void ImsiSToN ( u8 * pNormalImsi, u8 * pImsiStr )
|
|
{
|
|
if ( strlen ( pImsiStr ) != IMSI_LEN * 2 - 1 )
|
|
return;
|
|
pNormalImsi[0] = pImsiStr[0] - '0';
|
|
Str2Bcd ( pNormalImsi + 1, pImsiStr + 1, IMSI_LEN * 2 - 2 );
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : IsdnNToA
|
|
// Function: transfer ISDN format from normal to anti sequence
|
|
// Note : 918675557127001EEE --> 08916857551700E1
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
void IsdnNToA ( u8 * pAntiIsdn, u8 * pNormalIsdn )
|
|
{
|
|
u8 ii;
|
|
u8 aa = 0, bb = 0;
|
|
u8 len;
|
|
|
|
// nature of address and numbering plan indicator
|
|
pAntiIsdn[1] = pNormalIsdn[0];
|
|
len = 1;
|
|
for ( ii = 1; ii < ISDN_LEN; ii++ )
|
|
{
|
|
if ( pNormalIsdn[ii] == 0xee )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
aa = ( pNormalIsdn[ii] & 0x0f0 ) >> 4;
|
|
bb = pNormalIsdn[ii] & 0x0f;
|
|
if ( bb > 0x0c )
|
|
{
|
|
bb = 0x0f;
|
|
}
|
|
pAntiIsdn[ii + 1] = ( bb << 4 ) + aa;
|
|
len++;
|
|
}
|
|
}
|
|
pAntiIsdn[0] = len;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : IsdnAToN
|
|
// Function: transfer ISDN format from anti to normal sequence
|
|
// Note : 08916857551700E1 --> 918675557127001EEE
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
void IsdnAToN ( u8 * pNormalIsdn, u8 * pAntiIsdn )
|
|
{
|
|
u8 ii;
|
|
u8 aa = 0, bb = 0;
|
|
u8 uIsdnLen;
|
|
|
|
uIsdnLen = pAntiIsdn[0];
|
|
if ( uIsdnLen > ISDN_LEN )
|
|
uIsdnLen = ISDN_LEN;
|
|
pNormalIsdn[0] = pAntiIsdn[1];
|
|
for ( ii = 1; ii < uIsdnLen; ii++ )
|
|
{
|
|
if ( ( pAntiIsdn[ii + 1] & 0x0f ) >= 0x0e )
|
|
break;
|
|
aa = ( pAntiIsdn[ii + 1] & 0x0f0 ) >> 4;
|
|
if ( aa > 0x0c )
|
|
aa = 0x0e;
|
|
bb = pAntiIsdn[ii + 1] & 0x0f;
|
|
pNormalIsdn[ii] = ( bb << 4 ) + aa;
|
|
}
|
|
for ( ; ii < ISDN_LEN; ii++ )
|
|
pNormalIsdn[ii] = 0x0ee;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : IsdnNToS
|
|
// Function: transfer ISDN format from normal to ascii string
|
|
// Note : 918675557127001EEE --> "8675557127001"
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
void IsdnNToS ( u8 * pIsdnStr, u8 * pNormalIsdn )
|
|
{
|
|
u8 len = 0;
|
|
u8 ii, jj;
|
|
|
|
for ( ii = 1; ii < ISDN_LEN; ii++ )
|
|
{
|
|
jj = ( pNormalIsdn[ii] >> 4 ) & 0x0f;
|
|
if ( jj > 0x0c )
|
|
break;
|
|
pIsdnStr[len++] = jj + '0';
|
|
jj = pNormalIsdn[ii] & 0x0f;
|
|
if ( jj > 0x0c )
|
|
break;
|
|
pIsdnStr[len++] = jj + '0';
|
|
}
|
|
pIsdnStr[len] = '\0';
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : IsdnAToS
|
|
// Function: transfer ISDN format from anti to ascii string
|
|
// Note : 08916857551700E1 --> "8675557127001"
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
void IsdnAToS ( u8 * pAntiIsdn, u8 * pIsdnStr )
|
|
{
|
|
u8 ii;
|
|
u8 aa = 0, bb = 0;
|
|
u8 len = 0;
|
|
u8 uIsdnLen;
|
|
|
|
|
|
uIsdnLen = pAntiIsdn[0];
|
|
if ( uIsdnLen > ISDN_LEN )
|
|
uIsdnLen = ISDN_LEN;
|
|
|
|
for ( ii = 1; ii < uIsdnLen; ii++ )
|
|
{
|
|
if ((bb = ( pAntiIsdn[ii + 1] & 0x0f )) >= 0x0c)
|
|
break;
|
|
|
|
pIsdnStr[len++] = bb + '0';
|
|
|
|
if ((aa = ( pAntiIsdn[ii + 1] & 0x0f0 ) >> 4) >= 0x0c)
|
|
break;
|
|
|
|
pIsdnStr[len++] = aa + '0';
|
|
}
|
|
|
|
pIsdnStr[len] = '\0';
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : IsdnSToN
|
|
// Function: transfer ISDN format from ascii string to normal
|
|
// Note : "8675557127001" --> 918675557127001EEE
|
|
// Return : 0--string has error; 1--success
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
u8 IsdnSToN ( u8 * pNormalIsdn, u8 * pIsdnStr )
|
|
{
|
|
u8 ii;
|
|
u8 len;
|
|
|
|
len = strlen ( pIsdnStr );
|
|
if ( len > ISDN_LEN * 2 - 2 )
|
|
return 0;
|
|
if ( ( len % 2 ) == 1 ) // odd number
|
|
{
|
|
Str2Bcd ( pNormalIsdn + 1, pIsdnStr, len - 1 );
|
|
ii = len / 2 + 1;
|
|
pNormalIsdn[ii] = ( pIsdnStr[len - 1] - '0' ) << 4;
|
|
pNormalIsdn[ii] |= 0x0E;
|
|
}
|
|
else
|
|
{
|
|
Str2Bcd ( pNormalIsdn + 1, pIsdnStr, len );
|
|
ii = len / 2;
|
|
}
|
|
memset ( pNormalIsdn + ii + 1, 0xEE, ISDN_LEN - ii - 1 );
|
|
pNormalIsdn[0] = 0x91; // default value
|
|
return 1;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : GttToIsdn
|
|
// Function:
|
|
// Note :
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
void GttToIsdn ( u8 *pIsdn, u8 *pGtt )
|
|
{
|
|
u8 ii, jj;
|
|
|
|
pIsdn[0] = 0x91;
|
|
for ( ii = 1; ii < ISDN_LEN; ii++ )
|
|
{
|
|
jj = pGtt[ii - 1] & 0x0f;
|
|
if ( jj > 0x0c )
|
|
break;
|
|
pIsdn[ii] = jj << 4;
|
|
jj = ( pGtt[ii - 1] & 0xf0 ) >> 4;
|
|
if ( jj > 0x0c )
|
|
jj = 0x0e;
|
|
pIsdn[ii] |= jj;
|
|
if ( jj == 0x0e )
|
|
{
|
|
ii++;
|
|
break;
|
|
}
|
|
}
|
|
for ( ; ii < ISDN_LEN; ii++ )
|
|
pIsdn[ii] = 0xee;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : IsdnToGtai
|
|
// Function:
|
|
// Note :
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
u8 IsdnToGtai ( u8 * pGtai, u8 * pIsdn )
|
|
{
|
|
u8 tmpBuf[32];
|
|
u8 ii;
|
|
u8 len;
|
|
|
|
IsdnNToA ( tmpBuf, pIsdn );
|
|
ii = tmpBuf[0];
|
|
memcpy ( pGtai, tmpBuf + 2, ii - 1 );
|
|
if ( ( tmpBuf[ii] & 0x0f0 ) == 0x0f0 )
|
|
len = ii * 2 - 3;
|
|
else
|
|
len = ii * 2 - 2;
|
|
return len;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : GtaiToIsdn
|
|
// Function:
|
|
// Note :
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
void GtaiToIsdn ( u8 * pIsdn, u8 * pGtai, u8 len )
|
|
{
|
|
u8 tmpBuf[32];
|
|
|
|
tmpBuf[0] = ( len + 1 ) / 2;
|
|
tmpBuf[1] = 0x91;
|
|
memcpy ( tmpBuf + 2, pGtai, tmpBuf[0]++ );
|
|
IsdnAToN ( pIsdn, tmpBuf );
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : BcdToStrPE
|
|
// Function:
|
|
// Note :
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
u8 BcdToStrPE ( char *str, u8 * bcd, u8 bcd_len )
|
|
{
|
|
u8 ii = 0;
|
|
|
|
Bcd2Str ( str, bcd, bcd_len * 2 );
|
|
for ( ii = 0; ii < bcd_len * 2; ii++ )
|
|
{
|
|
if ( str[ii] == 'e' || str[ii] == 'E' )
|
|
break;
|
|
}
|
|
str[ii] = '\0';
|
|
return ii;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : AddCcToIsdn
|
|
// Function:
|
|
// Note :
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
void AddCcToIsdn ( u8 * isdn_str, u8 * cc )
|
|
{
|
|
char str1[32], str2[32];
|
|
u8 len, len1, len2;
|
|
|
|
len1 = BcdToStrPE ( str1, isdn_str + 1, ISDN_LEN - 1 );
|
|
len2 = BcdToStrPE ( str2, cc, 2 );
|
|
memcpy ( str2 + len2, str1, len1 );
|
|
len = len1 + len2;
|
|
if ( ( len % 2 ) != 0 )
|
|
str2[len++] = 'E';
|
|
str2[len] = '\0';
|
|
Str2Bcd ( isdn_str + 1, str2, len );
|
|
isdn_str[0] = 0x91;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Name : AddNdcToIsdn
|
|
// Function:
|
|
// Note :
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
void AddNdcToIsdn ( u8 * isdn_str, u8 * ndc )
|
|
{
|
|
char str1[32], str2[32];
|
|
u8 len, len1, len2;
|
|
|
|
len1 = GetBcdStr ( str1, isdn_str + 1, ISDN_LEN - 1 );
|
|
len2 = GetBcdStr ( str2, ndc, 3 ); //6 digit ndc
|
|
memcpy ( str2 + len2, str1, len1 );
|
|
len = len1 + len2;
|
|
if ( ( len % 2 ) != 0 )
|
|
str2[len++] = 'E';
|
|
Str2Bcd ( isdn_str + 1, str2, len );
|
|
isdn_str[0] = 0xa1;
|
|
}
|
|
|
|
void BcdToAsciiR(char *ascii_buf, const unsigned char *bcd_buf, int len)
|
|
{
|
|
char ch;
|
|
int i;
|
|
for(i=0;i<len;i++)
|
|
{
|
|
sprintf(&ascii_buf[i*2],"%02X",bcd_buf[i]);
|
|
ch = ascii_buf[i*2];
|
|
ascii_buf[i*2] = ascii_buf[i*2+1];
|
|
ascii_buf[i*2+1] = ch;
|
|
}
|
|
}
|
|
|