src/test_apps/tapi_sms_util.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Kyeongchul Kim <kyeongchul.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include "tapi_sms_util.h"
  26
  27
  28 void  reverse(char* x, int len)
  29 {
  30         int i, j = len - 1;
  31
  32         for (i = 0; i < j; i++)
  33         {
  34                 int t = x[i];
  35                 x[i] = x[j];
  36                 x[j--] = t;
  37         }
  38 }
  39
  40 char*  AcItoa(int n, char* str, int b)
  41 {
  42         int i = 0;
  43
  44         do
  45                 str[i++] = "0123456789ABCDEF"[n%b];
  46
  47         while ((n /= b) > 0);
  48         reverse(str, i);
  49         str[i] = '\0';
  50
  51         return str;
  52 }
  53
  54 int  AcToupper(int ch)
  55 {
  56         return (('a' <= (ch) && (ch) <= 'z')? ((ch) - ('a'-'A')) : (ch));
  57 }
  58
  59 char* SmsUtilUnpackGSMCode(char* szData, const char* pIn, int in_len )
  60 {
  61         int i;
  62         int pos = 0;
  63         int shift = 0;
  64
  65         /* If the number of fill bits != 0, then it would cause an additional shift */
  66         /*
  67         if ( shift != 0 )
  68                 pos = pos + 1;
  69
  70         if ( shift ==7 )
  71                 shift = 0;
  72         */
  73
  74         for ( i = 0; i < in_len; i++, pos++ )
  75         {
  76                 szData[i] = ( pIn[pos] << shift ) & 0x7F;
  77
  78                 if ( pos != 0 )
  79                 {
  80                         /* except the first byte, a character contains some bits
  81                         ** from the previous byte.
  82                         */
  83                         szData[i] |= pIn[pos-1] >> (8-shift);
  84                 }
  85
  86                 shift ++;
  87
  88                 if ( shift == 7 )
  89                 {
  90                         shift = 0;
  91
  92                         /* a possible extra complete character is available */
  93                         i++;
  94                         szData[i] = pIn[pos] >> 1;
  95
  96                         if( szData[i] == 0 )
  97                         {
  98                                 /* this is the end of the input, quit */
  99                                 break;
 100                         }
 101                 }
 102         }
 103
 104         return szData;
 105 }
 106
 107 int SmsUtilPackGSMCode( TS_BYTE* pOut, const char* szData, int in_len )
 108 {
 109         int i;
 110         int pos;
 111         int shift = 0;
 112         //shift = fill_bits;
 113
 114         //  memset( out, 0, out_len_max );
 115
 116         /* pack the ASCII characters
 117         */
 118         /*
 119         if ( shift == 7 )
 120                 shift = 0;
 121         */
 122
 123         for( pos = 0, i = 0; /*pos < out_len_max &&*/ i < in_len; pos++, i++ )
 124         {
 125                 /* pack the low bits */
 126                 pOut[pos] = szData[i] >> shift;
 127
 128                 if ( i + 1 < in_len )
 129                 {
 130                         /* pack the high bits using the low bits of the next character */
 131                         pOut[pos] |= szData[i+1] << ( 7 - shift );
 132
 133                         shift++;
 134
 135                         if( shift == 7 )
 136                         {
 137                                 shift = 0;
 138                                 i++;
 139                         }
 140                 }
 141         }
 142
 143         /* done */
 144         return pos;
 145 }
 146
 147
 148 void SmsUtilConvertBCD2Digit( char* pDigits, char* pBCD, int digitLen )
 149 {
 150         int             i, bcdLen;
 151         char    c[2];
 152         unsigned char   higher, lower;
 153
 154         if ( pBCD == NULL || pDigits == NULL )
 155         {
 156                 printf("__SmsConvertBCD2Digit: pBCD == NULL || pDigits == NULL. return.\n"  );
 157                 return;
 158         }
 159
 160         if ( digitLen == 0 )
 161         {
 162                 //printf("__SmsConvertBCD2Digit: digitLen == 0. return.\n" );
 163
 164                 pDigits[0] = 0x00;
 165
 166                 return;
 167         }
 168
 169         if ( digitLen % 2 )
 170                 bcdLen = digitLen / 2 + 1;
 171         else
 172                 bcdLen = digitLen / 2;
 173
 174         memset( pDigits, 0, bcdLen * 2 );
 175
 176         for ( i = 0; i < bcdLen; i++ )
 177         {
 178                 lower = pBCD[i] & 0x0F;                                 // get low nibble
 179
 180                 if ( lower == 0x0A )
 181                         lower = '*';
 182                 else if ( lower == 0x0B )
 183                         lower = '#';
 184                 else if ( lower == 0x0C )
 185                         lower = 'p';                    //DTMF Control pDigits seperator
 186                 else if ( lower == 0x0F )
 187                         lower = 0;
 188                 else
 189                 {
 190                         AcItoa( lower, c, 16 );
 191                         lower = (char) AcToupper(c[0]);
 192                 }
 193
 194                 higher = ( pBCD[i] >> 4 ) & 0x0F;                       // get high nibble
 195
 196                 if ( higher == 0x0A )
 197                         higher = '*';           // =0x2A
 198                 else if ( higher == 0x0B )
 199                         higher = '#';           // =0x23
 200                 else if ( higher == 0x0C )
 201                         higher = 'p';           // =0x70, DTMF Control pDigits seperator
 202                 else if ( higher == 0x0F ) // if higher semi-octet is 0x0F, filled bits.
 203                 {
 204                         //higher = 0;
 205                         sprintf(pDigits + strlen(pDigits), "%c", lower);
 206                         pDigits[/*digitLen-1*/bcdLen*2-1] = '\0';
 207
 208                         //printf("__SmsConvertBCD2Digit: pDigits [%s].\n", pDigits  );
 209
 210                         return;
 211                 }
 212                 else
 213                 {
 214                         AcItoa(higher, c, 16);
 215                         higher = (char) AcToupper(c[0]);
 216                 }
 217
 218                 //sprintf(pDigits, "%s%c%c", pDigits, lower, higher);
 219                 sprintf(pDigits + strlen(pDigits), "%c%c", lower, higher);
 220         }
 221
 222         pDigits[digitLen] = '\0';
 223
 224         //printf("__SmsConvertBCD2Digit: pDigits [%s].\n", pDigits  );
 225 }
 226
 227
 228 void SmsUtilConvertDigit2BCD( char* pBCD, char* pDigits, int digitLen )
 229 {
 230         int     i, j, digit;
 231
 232         unsigned char   higher, lower;
 233
 234         if ( pBCD == NULL || pDigits == NULL )
 235                 return;
 236
 237         // 0123456789 -> 1032547698
 238         for ( i = 0, j = 0; i < digitLen; i = i + 2, j++ )
 239         {
 240                 if ( pDigits[i] == '*' )
 241                         digit = 0x0A;
 242                 else if ( pDigits[i] == '#' )
 243                         digit = 0x0B;
 244                 else if ( AcToupper( pDigits[i] ) == 'P' )
 245                         digit = 0x0C;
 246                 else
 247                         digit = (int) ( pDigits[i] - '0' );
 248
 249                 lower = digit & 0x0F;
 250
 251                 if ( digitLen != i + 1 )
 252                 {
 253                         if ( pDigits[i+1] == '*' )
 254                                 digit = 0x0A;
 255                         else if ( pDigits[i+1] == '#' )
 256                                 digit = 0x0B;
 257                         else if ( AcToupper( pDigits[i+1] ) == 'P' )
 258                                 digit = 0x0C;
 259                         else
 260                                 digit = (int) ( pDigits[i+1] - '0' );
 261
 262                         higher = digit & 0x0F;
 263                 }
 264                 else
 265                 {
 266                         higher = 0xFF;
 267                 }
 268
 269                 pBCD[j] = ( higher << 4 ) | lower;
 270         }
 271 }
 272
 273
 274 TmDateTime* SmsUtilDecodeTimeStamp(char * pTimeStamp, TmDateTime *tmDateTime )
 275 {
 276         //TmDateTime tmDateTime;
 277         char szBuf[3];
 278         //TS_UINT32     time;
 279
 280         if ( pTimeStamp == NULL )
 281                 return NULL;
 282
 283         SmsUtilConvertBCD2Digit( szBuf, (char*) &pTimeStamp[0], 2 );
 284         tmDateTime->year = atoi( szBuf ) + 2000;
 285         if ( ( tmDateTime->year >= 1900 + MAX_YEAR )/* && ( tmDateTime->year < 2000 + BASE_YEAR )*/ )
 286                 tmDateTime->year -= 100;
 287         SmsUtilConvertBCD2Digit( szBuf, (char*) &pTimeStamp[1], 2 );
 288         tmDateTime->month = atoi( szBuf );
 289         SmsUtilConvertBCD2Digit( szBuf, (char*) &pTimeStamp[2], 2 );
 290         tmDateTime->day = atoi( szBuf );
 291         SmsUtilConvertBCD2Digit( szBuf, (char*) &pTimeStamp[3], 2 );
 292         tmDateTime->hour = atoi( szBuf );
 293         SmsUtilConvertBCD2Digit( szBuf, (char*) &pTimeStamp[4], 2 );
 294         tmDateTime->minute = atoi( szBuf );
 295         SmsUtilConvertBCD2Digit( szBuf, (char*) &pTimeStamp[5], 2 );
 296         tmDateTime->second = atoi( szBuf );
 297
 298         if ( ( tmDateTime->year < 1900 + BASE_YEAR ) || ( tmDateTime->year > 1900 + MAX_YEAR ) )
 299                 tmDateTime->year = 1900 + BASE_YEAR;
 300
 301         /*
 302         time = TmDateTimeToSeconds( &tmDateTime );
 303         if ( time > MAX_SECONDS )
 304                 time = MAX_SECONDS;
 305
 306         */
 307
 308         return tmDateTime;
 309 }
 310
 311 unsigned char* SmsUtilEncodeTimeStamp( TmDateTime* tmDateTime, unsigned char* pTimeStamp )
 312 {
 313         //TmDateTime tmDateTime;
 314         char szBuf[3];
 315         int     year;
 316
 317         if ( pTimeStamp == NULL )
 318                 return NULL;
 319
 320         memset( (void*) pTimeStamp, 0x00, sizeof ( unsigned char ) * 7 );
 321
 322         //TmSecondsToDateTime( timeStamp, &tmDateTime );
 323
 324         year = tmDateTime->year - 2000;
 325         if ( year < 0 )
 326                 year += 100;
 327         sprintf( szBuf, "%02d", year );
 328         SmsUtilConvertDigit2BCD( (char*) &pTimeStamp[0], szBuf, 2 );
 329         sprintf( szBuf, "%02d", tmDateTime->month );
 330         SmsUtilConvertDigit2BCD( (char*) &pTimeStamp[1], szBuf, 2 );
 331         sprintf( szBuf, "%02d", tmDateTime->day );
 332         SmsUtilConvertDigit2BCD( (char*) &pTimeStamp[2], szBuf, 2 );
 333         sprintf( szBuf, "%02d", tmDateTime->hour );
 334         SmsUtilConvertDigit2BCD( (char*) &pTimeStamp[3], szBuf, 2 );
 335         sprintf( szBuf, "%02d", tmDateTime->minute );
 336         SmsUtilConvertDigit2BCD( (char*) &pTimeStamp[4], szBuf, 2 );
 337         sprintf( szBuf, "%02d", tmDateTime->second );
 338         SmsUtilConvertDigit2BCD( (char*) &pTimeStamp[5], szBuf, 2 );
 339
 340
 341         /*      ignore Time zone (assume it is using 0x00 as default)
 342         timeZone = TmGetTimeZoneOffset() /15;
 343         if ( timeZone < 0 )
 344                 absTimeZone = -timeZone;
 345         else
 346                 absTimeZone = timeZone;
 347         */
 348
 349         sprintf( szBuf, "%02d", 0);
 350         SmsUtilConvertDigit2BCD( (char*) &pTimeStamp[6], szBuf, 2 );
 351
 352         //if ( timeZone < 0 )
 353         //      pTimeStamp[6] |= 0x80;
 354
 355         return pTimeStamp;
 356 }
 357
 358
 359
 360 int  SmsUtilDecodeAddrField(char *diallingNum, char* pAddrField, int *result_ton, int *result_npi )
 361 {
 362         int index = 0;
 363         int  ton,npi;
 364         int DialNumLen=0;
 365
 366         ton = ( pAddrField[index+1] & 0x70 ) >> 4;
 367         npi = pAddrField[index+1] & 0x0F;
 368
 369         if ( ton != SIM_TON_ALPHA_NUMERIC )
 370         {
 371                 // Origination/Destination address �ʵ忡���� length�� ���� address length
 372                 // origination/destination address �ʵ��� ��� length�� 0 �� ���� number type/plan �ʵ�� 0xFF ���� ���´�.
 373                 DialNumLen = pAddrField[index++];
 374         }
 375         else
 376         {
 377                 DialNumLen = ( ( ( pAddrField[index++] + 1 ) / 2 ) * 8 ) / 7;
 378         }
 379
 380
 381
 382
 383         // SIM_SMSP_ADDRESS_LEN ���� address length �� ũ�� SIM_SMSP_ADDRESS_LEN ��ŭ�� ��ȯ�� �Ѵ�.
 384
 385         if ( DialNumLen > SIM_SMSP_ADDRESS_LEN )
 386         {
 387                 DialNumLen = SIM_SMSP_ADDRESS_LEN;
 388         }
 389
 390         printf(" DialNumLen = %d\n", DialNumLen  );
 391
 392         index++; /* ignore Type of Address field */
 393
 394         if (ton != SIM_TON_ALPHA_NUMERIC )
 395         {
 396                 SmsUtilConvertBCD2Digit( diallingNum, (char*) &pAddrField[index],DialNumLen );
 397         }
 398         else
 399         {
 400                 SmsUtilUnpackGSMCode( diallingNum, &pAddrField[index],DialNumLen );
 401         }
 402
 403         printf(  "__SmsDecodeAddrField: diallingNum [%s].\n", (char*) diallingNum  );
 404
 405         *result_ton=ton;
 406         *result_npi=npi;
 407
 408         printf("ton %d npi %d\n",ton,npi);
 409
 410         return DialNumLen;
 411
 412
 413 }
 414
 415 int  SmsUtilEncodeAddrField(unsigned char* pAddrField, char* diallingNum, int DialNumLen, int ton, int npi )
 416 {
 417         int index = 0;
 418
 419         if ( diallingNum == NULL || pAddrField == NULL )
 420                 return -1;
 421
 422         if ( ton != SIM_TON_ALPHA_NUMERIC )
 423         {
 424                 // Origination/Destination address �ʵ忡���� length�� ���� address length
 425                 pAddrField[index++] = (unsigned char)DialNumLen;
 426                 //printf(" addr len packet: %d\n", pAddrField[index]);
 427         }
 428         else
 429         {
 430                 pAddrField[index] = (unsigned char) ( ( ( DialNumLen * 7 + 7 ) / 8 ) * 2 );
 431
 432                 // ������ ����Ʈ���� ���� 4��Ʈ�� ������ ������ length �ʵ尪�� -1�� �Ѵ�.
 433                 if ( ( ( DialNumLen * 7 ) % 8 ) <= 4 )
 434                         pAddrField[index]--;
 435
 436                 printf(" addr len packet: %d out of SIM_TON_ALPAHA\n", pAddrField[index]);
 437
 438                 index++;
 439
 440
 441
 442         }
 443
 444         SET_TON_NPI( pAddrField[index], ton, npi );
 445
 446         index++; // SET_TON_NPI �� MACRO �̹Ƿ� ���ο��� ������Ű�� ����
 447
 448         if ( ton != SIM_TON_ALPHA_NUMERIC )
 449         {
 450                 SmsUtilConvertDigit2BCD( (char*) &pAddrField[index], (char*) diallingNum, DialNumLen );
 451
 452                 if ( DialNumLen % 2 )
 453                         index += DialNumLen / 2 + 1;
 454                 else
 455                         index += DialNumLen / 2;
 456         }
 457         else
 458         {
 459                 index += SmsUtilPackGSMCode( &pAddrField[index], diallingNum, (int) DialNumLen );
 460         }
 461
 462         return index;
 463 }
 464 int SmsUtilDecodeScAddrField( TelSmsAddressInfo_t* pSmsAddrField, TS_BYTE* pAddrField )
 465 {
 466         printf("SmsUtilDecodeScAddrField\n");
 467         int index = 0;
 468         int length = 0;
 469
 470         if ( pSmsAddrField == NULL || pAddrField == NULL )
 471         {
 472                 printf( "SmsUtilDecodeScAddrField: pSimAddrField or pAddrField is NULL.\n"  );
 473
 474                 return 0;
 475         }
 476
 477         // Service Center address �ʵ忡���� length�� �ڿ� ������ byte�� ��
 478         // -> ���� address ���̴� TON/API ����Ʈ�� �����ϰ� ������ ����Ʈ�� 2�� or 2�� - 1(���� ���̰� Ȧ���ΰ��)
 479         length = pAddrField[index];
 480         // ������ ���� �޽����� ��쿡�� service center address�� ���� ���� �ִ�.
 481         // �� ��쿡 length �� 0 �̸� number type, plan �� ��� ���
 482         // length �� 1 �̸� type, plan �� �ִ� ���
 483         if ( length > 1 )
 484         {
 485                 pSmsAddrField->DialNumLen = ( pAddrField[index++] - 1 ) * 2; // -1�� TON/API �ʵ�
 486
 487                 // SIM_SMSP_ADDRESS_LEN ���� address length �� ũ�� SIM_SMSP_ADDRESS_LEN ��ŭ�� ��ȯ�� �Ѵ�.
 488                 if ( pSmsAddrField->DialNumLen > SIM_SMSP_ADDRESS_LEN )
 489                 {
 490                         pSmsAddrField->DialNumLen = SIM_SMSP_ADDRESS_LEN;
 491                 }
 492
 493                 pSmsAddrField->Ton = ( pAddrField[index] & 0x70 ) >> 4;
 494                 pSmsAddrField->Npi = pAddrField[index] & 0x0F;
 495
 496                 index++; /* ignore Type of Address field */
 497
 498                 SmsUtilConvertBCD2Digit( (char*) pSmsAddrField->DialNumLen, (char*) &pAddrField[index], pSmsAddrField->DialNumLen );
 499
 500                 printf( "SmsUtilDecodeScAddrField: diallingNum [%s].\n", (char*) pSmsAddrField->DialNumLen  );
 501
 502                 printf( "length=%d , ton %d, npi =%d\n",pSmsAddrField->DialNumLen, pSmsAddrField->Ton,pSmsAddrField->Npi );
 503         }
 504
 505         return ++length;
 506 }
 507
 508  int  SmsUtilEncodeScAddrField( TS_BYTE* pAddrField, TelSmsAddressInfo_t * pSmsAddrField )
 509 {
 510         int index = 0;
 511
 512         if ( pSmsAddrField == NULL || pAddrField == NULL )
 513                 return -1;
 514
 515         // Service Center address �ʵ忡���� length�� �ڿ� ������ byte�� ��
 516         // -> ���� address ���̴� TON/API ����Ʈ�� �����ϰ� ������ ����Ʈ�� 2�� or 2�� - 1(���� ���̰� Ȧ���ΰ��)
 517         if ( pSmsAddrField->DialNumLen % 2 )
 518         {
 519                 pAddrField[index++] = pSmsAddrField->DialNumLen / 2 + 1 + 1; // +1 �� TON/NPI �ʵ�, Ȧ������ ���� ������ ���߱� ���� �ѹ� �� +1
 520         }
 521         else
 522         {
 523                 pAddrField[index++] = pSmsAddrField->DialNumLen / 2 + 1; // +1 �� TON/NPI �ʵ�
 524         }
 525
 526         SET_TON_NPI( pAddrField[index], pSmsAddrField->Ton, pSmsAddrField->Npi );
 527
 528         index++; // SET_TON_NPI �� MACRO �̹Ƿ� ���ο��� ������Ű�� ���׹߻�
 529
 530         SmsUtilConvertDigit2BCD( (char*) &pAddrField[index], (char*) pSmsAddrField->DialNumLen, pSmsAddrField->DialNumLen );
 531
 532         if ( pSmsAddrField->DialNumLen % 2 )
 533                 index += pSmsAddrField->DialNumLen / 2 + 1;
 534         else
 535                 index += pSmsAddrField->DialNumLen / 2;
 536
 537         return index;
 538 }
 539
 540 void SmsUtilDecodeDCS( tapi_nettext_coding_scheme* pCodingScheme,   unsigned char dcs )
 541 {
 542         assert( pCodingScheme != NULL );
 543
 544         memset( pCodingScheme, 0, sizeof ( tapi_nettext_coding_scheme ) );
 545
 546         if ( dcs < 0x40 ) // bits 7..4 = 00xx : general data coding indication
 547         {
 548                 pCodingScheme->coding_group_type = TAPI_NETTEXT_CODGRP_SM_GENERAL_DCS;
 549
 550                 if ( dcs & 0x20 ) // bit 5 = 1 : indicates the text is compressed
 551                         pCodingScheme->bCompressed = TRUE;
 552
 553                 if ( dcs & 0x10 ) // bit 4 = 1 : indicates that bits  1 to 0 have a message class meaning
 554                 {
 555                         pCodingScheme->bmsg_class_set = TRUE;
 556
 557                         switch ( dcs & 0x03 ) // bits 1 to 0 : message class
 558                         {
 559                                 case 0x00:
 560                                         pCodingScheme->class_type = TAPI_NETTEXT_CLASS_0;
 561                                         break;
 562                                 case 0x01:
 563                                         pCodingScheme->class_type = TAPI_NETTEXT_CLASS_1;
 564                                         break;
 565                                 case 0x02:
 566                                         pCodingScheme->class_type = TAPI_NETTEXT_CLASS_2;
 567                                         break;
 568                                 case 0x03:
 569                                         pCodingScheme->class_type = TAPI_NETTEXT_CLASS_3;
 570                                         break;
 571                         }
 572                 }
 573                 else // bit 4 = 0 : indicates that bits 1 to 0 are reserved and have no message class meaning
 574                         pCodingScheme->class_type = TAPI_NETTEXT_CLASS_NONE;
 575
 576                 switch ( dcs & 0x0C ) // bits 4 to 3 : character set
 577                 {
 578                         case 0x00:
 579                                 pCodingScheme->alphabet_type = TAPI_NETTEXT_ALPHABET_DEFAULT;
 580                                 break;
 581                         case 0x04:
 582                                 pCodingScheme->alphabet_type = TAPI_NETTEXT_ALPHABET_8BIT;
 583                                 break;
 584                         case 0x08:
 585                                 pCodingScheme->alphabet_type = TAPI_NETTEXT_ALPHABET_UCS2;
 586                                 break;
 587                         case 0x0C:
 588                                 pCodingScheme->alphabet_type = TAPI_NETTEXT_ALPHABET_MAX;
 589                                 break;
 590                 }
 591         }
 592         else if ( dcs >= 0x40 && dcs < 0x80 ) // bits 7..4 = 01xx : message marked for automatic deletion group. bits 5..0 are coded exactly the same as group 00xx
 593         {
 594                 pCodingScheme->coding_group_type = TAPI_NETTEXT_CODGRP_SM_AUTO_DELETION;
 595
 596                 if ( dcs & 0x20 ) // bit 5 = 1 : indicates the text is compressed
 597                         pCodingScheme->bCompressed = TRUE;
 598
 599                 if ( dcs & 0x10 ) // bit 4 = 1 : indicates that bits  1 to 0 have a message class meaning
 600                 {
 601                         pCodingScheme->bmsg_class_set = TRUE;
 602
 603                         switch ( dcs & 0x03 ) // bits 1 to 0 : message class
 604                         {
 605                                 case 0x00:
 606                                         pCodingScheme->class_type = TAPI_NETTEXT_CLASS_0;
 607                                         break;
 608                                 case 0x01:
 609                                         pCodingScheme->class_type = TAPI_NETTEXT_CLASS_1;
 610                                         break;
 611                                 case 0x02:
 612                                         pCodingScheme->class_type = TAPI_NETTEXT_CLASS_2;
 613                                         break;
 614                                 case 0x03:
 615                                         pCodingScheme->class_type = TAPI_NETTEXT_CLASS_3;
 616                                         break;
 617                         }
 618                 }
 619                 else // bit 4 = 0 : indicates that bits 1 to 0 are reserved and have no message class meaning
 620                         pCodingScheme->class_type = TAPI_NETTEXT_CLASS_NONE;
 621
 622                 switch ( dcs & 0x0C ) // bits 4 to 3 : character set
 623                 {
 624                         case 0x00:
 625                                 pCodingScheme->alphabet_type = TAPI_NETTEXT_ALPHABET_DEFAULT;
 626                                 break;
 627                         case 0x04:
 628                                 pCodingScheme->alphabet_type = TAPI_NETTEXT_ALPHABET_8BIT;
 629                                 break;
 630                         case 0x08:
 631                                 pCodingScheme->alphabet_type = TAPI_NETTEXT_ALPHABET_UCS2;
 632                                 break;
 633                         case 0x0C:
 634                                 pCodingScheme->alphabet_type = TAPI_NETTEXT_ALPHABET_MAX;
 635                                 break;
 636                 }
 637         }
 638         // bits 7..4 = 1000 ~ 1011 : reserved
 639         else if ( dcs == 0xC0 ) // bits 7..4 = 1100 : message waiting indication group, discard message
 640         {
 641                 pCodingScheme->coding_group_type = TAPI_NETTEXT_CODGRP_SM_WAITING_DISCARD;
 642         }
 643         else if ( dcs < 0xE0 )
 644         {
 645                 pCodingScheme->coding_group_type = TAPI_NETTEXT_CODGRP_SM_WAITING_STORE;
 646
 647                 if ( dcs & 0x08 )
 648                         pCodingScheme->bmsg_ind_active = TRUE;
 649
 650                 switch ( dcs & 0x03 )
 651                 {
 652                         case 0x00:
 653                                 pCodingScheme->waiting_type = TAPI_NETTEXT_WAITING_VOICE_MSG;
 654                                 break;
 655                         case 0x01:
 656                                 pCodingScheme->waiting_type = TAPI_NETTEXT_WAITING_FAX_MSG;
 657                                 break;
 658                         case 0x02:
 659                                 pCodingScheme->waiting_type = TAPI_NETTEXT_WAITING_EMAIL_MSG;
 660                                 break;
 661                         case 0x03:
 662                                 pCodingScheme->waiting_type = TAPI_NETTEXT_WAITING_OTHER_MSG;
 663                                 break;
 664                 }
 665         }
 666         else if ( dcs < 0xF0 )
 667         {
 668                 pCodingScheme->coding_group_type = TAPI_NETTEXT_CODGRP_SM_WAITING_STORE_UCS2;
 669
 670                 if ( dcs & 0x08 )
 671                         pCodingScheme->bmsg_ind_active = TRUE;
 672
 673                 switch ( dcs & 0x03 )
 674                 {
 675                         case 0x00:
 676                                 pCodingScheme->waiting_type = TAPI_NETTEXT_WAITING_VOICE_MSG;
 677                                 break;
 678                         case 0x01:
 679                                 pCodingScheme->waiting_type = TAPI_NETTEXT_WAITING_FAX_MSG;
 680                                 break;
 681                         case 0x02:
 682                                 pCodingScheme->waiting_type = TAPI_NETTEXT_WAITING_EMAIL_MSG;
 683                                 break;
 684                         case 0x03:
 685                                 pCodingScheme->waiting_type = TAPI_NETTEXT_WAITING_OTHER_MSG;
 686                                 break;
 687                 }
 688         }
 689         else
 690         {
 691                 pCodingScheme->coding_group_type = TAPI_NETTEXT_CODGRP_SM_CLASS_CODING;
 692
 693                 if ( dcs & 0x04 )
 694                         pCodingScheme->alphabet_type = TAPI_NETTEXT_ALPHABET_8BIT;
 695
 696                 switch ( dcs & 0x03 )
 697                 {
 698                         case 0x00:
 699                                 pCodingScheme->class_type = TAPI_NETTEXT_CLASS_0;
 700                                 break;
 701                         case 0x01:
 702                                 pCodingScheme->class_type = TAPI_NETTEXT_CLASS_1;
 703                                 break;
 704                         case 0x02:
 705                                 pCodingScheme->class_type = TAPI_NETTEXT_CLASS_2;
 706                                 break;
 707                         case 0x03:
 708                                 pCodingScheme->class_type = TAPI_NETTEXT_CLASS_3;
 709                                 break;
 710                 }
 711         }
 712 }
 713
 714 void SmsUtilEncodeDCS( TS_BYTE* pDCS, tapi_nettext_coding_scheme* pCodingScheme )
 715 {
 716         printf("SmsUtilEncodeDCS Start\n");
 717         TS_BYTE dcs = 0x00;
 718
 719         assert( pCodingScheme != NULL );
 720
 721         if( pCodingScheme->coding_group_type == TAPI_NETTEXT_CODGRP_SM_GENERAL_DCS ) // bit 7..4 is 00xx
 722         {
 723                 if ( pCodingScheme->bCompressed )
 724                                 dcs |= 0x20; // bit 5 is 1
 725
 726                         if ( pCodingScheme->bmsg_class_set )
 727                         {
 728                                 dcs |= 0x10; // bit 4 is 1
 729
 730                                 if( pCodingScheme->class_type== TAPI_NETTEXT_CLASS_0 )
 731                                         dcs |= 0x00;
 732
 733                                 else if ( pCodingScheme->class_type == TAPI_NETTEXT_CLASS_1 )
 734                                         dcs |= 0x01;
 735
 736                                 else if ( pCodingScheme->class_type == TAPI_NETTEXT_CLASS_2 )
 737                                         dcs |= 0x02;
 738
 739                                 else if ( pCodingScheme->class_type == TAPI_NETTEXT_CLASS_3 )
 740                                         dcs |= 0x03;
 741                         }
 742
 743                         switch ( pCodingScheme->alphabet_type )
 744                         {
 745                                 case TAPI_NETTEXT_ALPHABET_DEFAULT: // bit 3..2 is 00
 746                                 {
 747                                         dcs |= 0x00;
 748                                         break;
 749                                 }
 750                                 case TAPI_NETTEXT_ALPHABET_8BIT: // bit 3..2 is 01
 751                                 {
 752                                         dcs |= 0x04;
 753                                         break;
 754                                 }
 755                                 case TAPI_NETTEXT_ALPHABET_UCS2: // bit 3..2 is 10
 756                                 {
 757                                         dcs |= 0x08;
 758                                         break;
 759                                 }
 760                                 default: // bit 3..2 is 11
 761                                 {
 762                                         dcs |= 0x0C;
 763                                         break;
 764                                 }
 765                         }
 766         }
 767         else if ( pCodingScheme->coding_group_type == TAPI_NETTEXT_CODGRP_SM_WAITING_DISCARD ) // bit 7..4 is 1100
 768         {
 769                 dcs |= 0xC0;
 770         }
 771         else if ( pCodingScheme->coding_group_type == TAPI_NETTEXT_CODGRP_SM_WAITING_STORE ) // bit 7..4 is 1101
 772         {
 773                 dcs |= 0xD0;
 774
 775                 if ( pCodingScheme->bmsg_ind_active ) // bit 3..2 is 10
 776                         dcs |= 0x08;
 777
 778                 else if( pCodingScheme->waiting_type == TAPI_NETTEXT_WAITING_VOICE_MSG)
 779                         dcs |= 0x00;
 780
 781                 else if( pCodingScheme->waiting_type == TAPI_NETTEXT_WAITING_FAX_MSG)
 782                         dcs |= 0x01;
 783
 784                 else if( pCodingScheme->waiting_type == TAPI_NETTEXT_WAITING_EMAIL_MSG) // bit 1..0 is 10
 785                         dcs |= 0x02;
 786
 787                 else if( pCodingScheme->waiting_type == TAPI_NETTEXT_WAITING_OTHER_MSG) // bit 1..0 is 11
 788                         dcs |= 0x03;
 789
 790         }
 791         else if ( pCodingScheme->coding_group_type == TAPI_NETTEXT_CODGRP_SM_WAITING_STORE_UCS2 ) // bit 7..4 is 1110
 792         {
 793                 dcs |= 0xE0;
 794
 795                 if ( pCodingScheme->bmsg_ind_active ) // bit 3..2 is 10
 796                         dcs |= 0x08;
 797
 798                 if( pCodingScheme->waiting_type == TAPI_NETTEXT_WAITING_VOICE_MSG ) // bit 1..0 is 00
 799                         dcs |= 0x00;
 800
 801                 else if( pCodingScheme->waiting_type == TAPI_NETTEXT_WAITING_FAX_MSG )
 802                         dcs |= 0x01;
 803
 804                 else if( pCodingScheme->waiting_type == TAPI_NETTEXT_WAITING_EMAIL_MSG )
 805                         dcs |= 0x02;
 806
 807                 else if( pCodingScheme->waiting_type == TAPI_NETTEXT_WAITING_OTHER_MSG )
 808                         dcs |= 0x03;
 809         }
 810         else if ( pCodingScheme->coding_group_type == TAPI_NETTEXT_CODGRP_SM_CLASS_CODING )     // bit 7..4 is 1111
 811         {
 812                 dcs |= 0xF0;
 813
 814                 if( pCodingScheme->alphabet_type == TAPI_NETTEXT_ALPHABET_DEFAULT )     // bit 2 is 0
 815                         dcs |= 0x00;
 816                 else if( pCodingScheme->alphabet_type == TAPI_NETTEXT_ALPHABET_8BIT ) // bit 2 is 1
 817                         dcs |= 0x04;
 818
 819                 if( pCodingScheme->class_type == TAPI_NETTEXT_CLASS_0) // bit 1..0 is 00
 820                         ;
 821
 822                 else if( pCodingScheme->class_type == TAPI_NETTEXT_CLASS_1) // bit 1..0 is 01
 823                         dcs |= 0x01;
 824
 825                 else if( pCodingScheme->class_type == TAPI_NETTEXT_CLASS_2) // bit 1..0 is 10
 826                         dcs |= 0x02;
 827
 828                 else if( pCodingScheme->class_type == TAPI_NETTEXT_CLASS_3) // bit 1..0 is 11
 829                         dcs |= 0x03;
 830         }
 831
 832         memcpy( pDCS, &dcs, sizeof ( TS_BYTE ) );
 833
 834         printf("SmsUtilEncodeDCS End\n");
 835 }
 836
 837  TS_UINT8 SmsUtilEncodeValidity( TS_BYTE* pValidity, tapi_nettext_vp* pVP )
 838 {
 839         TS_UINT8        pos = 0;
 840
 841         switch( pVP->vp_type )
 842         {
 843                 case TAPI_NETTEXT_VP_NOT_USED:
 844                         break;
 845
 846                 case TAPI_NETTEXT_VP_RELATIVE:
 847                         pValidity[pos] = (TS_UINT8) pVP->vpValue;
 848                         pos ++;
 849                         break;
 850
 851                 case TAPI_NETTEXT_VP_ABSOLUTE:
 852                         //TO DO
 853                         //SmsUtilEncodeTimeStamp( pValidity, pVP->vpValue );
 854                         pos += 7;
 855                         break;
 856
 857                 case TAPI_NETTEXT_VP_ENHANCED:
 858                         break;
 859         }
 860
 861         return pos;
 862 }
 863