//////////////////////////////////////////////////
//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;
   }
}