wearable/test_src/sms.c

   1 /*
   2  * Telephony test application
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@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 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/time.h>
  25 #include <unistd.h>
  26 #include <glib.h>
  27
  28 #include <tapi_common.h>
  29 #include <TelSms.h>
  30 #include <TapiUtility.h>
  31 #include <ITapiNetText.h>
  32
  33 #include "menu.h"
  34 #include "sms.h"
  35 #include "sms_util.h"
  36
  37 // Global Variabl
  38 int dcs_pos = 0;
  39 unsigned int SmsMsgId = 0;
  40 unsigned char tp_mr = 0x00;
  41
  42 char *cmdString[] = { "TAPI_SERVICE_SMS_SEND_UMTS_MSG",
  43                 "TAPI_SERVICE_SMS_READ_MSG", "TAPI_SERVICE_SMS_SAVE_MSG",
  44                 "TAPI_SERVICE_SMS_DELETE_MSG", "TAPI_SERVICE_SMS_GET_COUNT",
  45                 "TAPI_SERVICE_SMS_GET_SCA", "TAPI_SERVICE_SMS_SET_SCA",
  46                 "TAPI_SERVICE_SMS_GET_CB_CONFIG", "TAPI_SERVICE_SMS_SET_CB_CONFIG",
  47                 "TAPI_SERVICE_SMS_SET_MEM_STATUS", "TAPI_SERVICE_SMS_GET_PREF_BEARER",
  48                 "TAPI_SERVICE_SMS_SET_PREF_BEARER",
  49                 "TAPI_SERVICE_SMS_SET_DELIVERY_REPORT",
  50                 "TAPI_SERVICE_SMS_SET_MSG_STATUS", "TAPI_SERVICE_SMS_GET_PARAMS",
  51                 "TAPI_SERVICE_SMS_SET_PARAMS", "TAPI_SERVICE_SMS_GET_PARAMCNT",
  52                 "TAPI_SERVICE_SMS_SEND_CDMA_MSG" };
  53
  54 static void on_resp_send_msg (TapiHandle *handle, int result, void *data,
  55                 void *user_data);
  56 static void on_resp_read_msg (TapiHandle *handle, int result, void *data,
  57                 void *user_data);
  58 static void on_resp_save_msg (TapiHandle *handle, int result, void *data,
  59                 void *user_data);
  60 static void on_resp_DeliverReport_msg (TapiHandle *handle, int result,
  61                 void *data, void *user_data);
  62
  63 #ifdef TODO_BY_JYGU
  64 static BOOL EncodeCdmaSmsParamTeleservice(int teleservice_id ,ParamTeleserv_t *ParamTeleserv)
  65 {
  66         BOOL ret = FALSE;
  67
  68         if(ParamTeleserv == NULL) {
  69                 printf("[EncodeCdmaSmsParamTeleservice] NULL pointer  \n");
  70                 return ret;
  71         }
  72
  73         switch(teleservice_id) {
  74                 case TELESERVICEID_CPT95:
  75                 case TELESERVICEID_CMT95:
  76                 case TELESERVICEID_VMN95:
  77                 case TELESERVICEID_WAP:
  78                 ret = TRUE;
  79                 break;
  80                 default:
  81                 ret = FALSE;
  82         }
  83
  84         if(ret == TRUE) {
  85                 ParamTeleserv->param_id = PARAMID_TELESERVICE_ID;
  86                 ParamTeleserv->param_len = 2;
  87                 ParamTeleserv->teleserv_id = teleservice_id;
  88         }
  89
  90         return ret;
  91 }
  92
  93 static BOOL EncodeCdmaSmsParamDestAddress(int NumberPlan, char* diallingNum ,ParamAddress_t *ParamAddr)
  94 {
  95         BOOL ret = FALSE;
  96         int length = 0;
  97
  98         if(ParamAddr == NULL || diallingNum == NULL) {
  99                 printf("[EncodeCdmaSmsParamAddress] NULL pointer  \n");
 100                 return ret;
 101         }
 102
 103         length = strlen(diallingNum); //remove CR
 104
 105         ParamAddr->param_id = PARAMID_ADDRESS;
 106         ParamAddr->len = length;
 107         ParamAddr->digit = DIGITMODE_4BITDTMF;
 108         ParamAddr->num = NUMMODE_NONE_DATANETWORK;
 109         ParamAddr->numtype = NUMBER_TYPE_UNKNOWN;
 110         ParamAddr->numplan = NumberPlan;
 111
 112         strncpy((char *)ParamAddr->CHARi, diallingNum, length);
 113
 114         length +=5;
 115         ParamAddr->param_len = length;
 116
 117         ret = TRUE;
 118
 119         return ret;
 120 }
 121
 122 static BOOL EncodeCdmaSmsParamCallbackAddress(int NumberPlan, char* diallingNum ,ParamCallback_t *ParamCallback)
 123 {
 124         BOOL ret = FALSE;
 125         int length = 0;
 126
 127         if(ParamCallback == NULL || diallingNum == NULL) {
 128                 printf("[EncodeCdmaSmsParamAddress] NULL pointer  \n");
 129                 return ret;
 130         }
 131
 132         length = strlen(diallingNum); //remove CR
 133
 134         ParamCallback->param_id = PARAMID_CALLBACK;
 135         ParamCallback->digit = DIGITMODE_4BITDTMF;
 136         ParamCallback->numtype = NUMBER_TYPE_UNKNOWN;
 137         ParamCallback->numplan = NumberPlan;
 138         ParamCallback->len = length;
 139         strncpy((char *)ParamCallback->CHARi, diallingNum, length);
 140
 141         length +=4;
 142         ParamCallback->param_len = length;
 143
 144         ret = TRUE;
 145
 146         return ret;
 147 }
 148
 149 static BOOL EncodeCdmaSmsParamMsgId(int type, ParamMsgId_t *ParamMsg)
 150 {
 151         BOOL ret = FALSE;
 152
 153         if(ParamMsg == NULL) {
 154                 printf("[EncodeCdmaSmsParamMsgId] NULL pointer  \n");
 155                 return ret;
 156         }
 157
 158         ParamMsg->param_id = PARAMID_MESSAGE_ID;
 159         ParamMsg->param_len =3;
 160         ParamMsg->type = type;
 161         ParamMsg->msg_id = SmsMsgId++;
 162
 163         ret = TRUE;
 164
 165         return ret;
 166 }
 167
 168 static BOOL EncodeCdmaSmsParamUserData(char* SendTxt, ParamUserData_t *ParamUser)
 169 {
 170         BOOL ret = FALSE;
 171         int length = 0;
 172
 173         if(ParamUser == NULL || SendTxt == NULL) {
 174                 printf("[EncodeCdmaSmsParamUserData] NULL pointer  \n");
 175                 return ret;
 176         }
 177
 178         length = strlen(SendTxt);
 179
 180         ParamUser->param_id = PARAMID_USER_DATA;
 181         ParamUser->encoding = MSGENCODING_7BIT_ASCII;
 182         strncpy((char *)ParamUser->CHARi, SendTxt, length);
 183
 184         ParamUser->len = length;
 185         length += 2;;
 186         ParamUser->param_len = length;
 187
 188         ret = TRUE;
 189
 190         return ret;
 191 }
 192 #endif
 193
 194 static BOOL EncodeCdmaSmsSubmitTpdu (char* diallingNum, int dialNumLen,
 195                 char* msgTxt, int msg_len)
 196 {
 197 #ifdef TODO_BY_JYGU
 198         ParamTeleserv_t ParamTeleserv = {0,};
 199         ParamAddress_t ParamAddr = {0,};
 200         ParamMsgId_t ParamMsg = {0,};
 201         ParamUserData_t ParamUser = {0,};
 202
 203         int i;
 204         int requestId = 0;
 205
 206         msg("EncodeCdmaSmsSubmitTpdu Func Enter");
 207
 208         TelSmsMsgInfo_t *pDataPackage = malloc(sizeof(TelSmsMsgInfo_t));
 209         memset(pDataPackage, 0, sizeof(TelSmsMsgInfo_t));
 210
 211         pDataPackage->MsgType = SMS_MESSAGETYPE_SUBMIT;
 212
 213         //1 TeleService Identifier
 214         EncodeCdmaSmsParamTeleservice(TELESERVICEID_CMT95, &ParamTeleserv);
 215         pDataPackage->ParamMask |= SMS_PARAM_TELESERVICE_MASK;
 216         memcpy(&pDataPackage->MsgData.OutSubmit.TeleService, &ParamTeleserv.teleserv_id, sizeof(unsigned short));
 217         msg("teleservice at TEST APP: 0x%x", pDataPackage->MsgData.OutSubmit.TeleService);
 218
 219         //1 Destination Address
 220         diallingNum[dialNumLen] = '\0';
 221         EncodeCdmaSmsParamDestAddress(NUMBER_PLAN_UNKNOWN, diallingNum, &ParamAddr);
 222         pDataPackage->ParamMask |= SMS_PARAM_ADDRESS_MASK;
 223         pDataPackage->MsgData.OutSubmit.DstAddr.Digit = ParamAddr.digit;
 224         pDataPackage->MsgData.OutSubmit.DstAddr.NumberMode = ParamAddr.num;
 225         pDataPackage->MsgData.OutSubmit.DstAddr.NumberType = ParamAddr.numtype;
 226         pDataPackage->MsgData.OutSubmit.DstAddr.NumberPlan = ParamAddr.numplan;
 227         pDataPackage->MsgData.OutSubmit.DstAddr.szAddrLength = ParamAddr.len;
 228         memcpy(pDataPackage->MsgData.OutSubmit.DstAddr.szAddress, ParamAddr.CHARi, ParamAddr.len);
 229
 230         //1  Message Identifier
 231         EncodeCdmaSmsParamMsgId(MESSAGETYPE_SUBMIT, &ParamMsg);
 232         pDataPackage->ParamMask |= SMS_PARAM_MESSAGE_ID_MASK;
 233         pDataPackage->MsgData.OutSubmit.MsgId = ParamMsg.type;
 234         pDataPackage->MsgType = ParamMsg.type;
 235
 236         //1  bearer
 237         pDataPackage->ParamMask |= SMS_PARAM_BEARER_REPLY_MASK;
 238         pDataPackage->MsgData.OutSubmit.ReplySeqNumber = 1;
 239
 240 #if 0
 241         //1 Callback Address
 242         EncodeCdmaSmsParamCallbackAddress(NUMBER_PLAN_UNKNOWN, CallbackNum, &Paramcallback);
 243         pDataPackage->ParamMask |= SMS_PARAM_CALLBACK_MASK;
 244         pDataPackage->MsgData.OutSubmit.CallBackNumber.Digit = Paramcallback.digit;
 245         pDataPackage->MsgData.OutSubmit.CallBackNumber.NumberType = Paramcallback.numtype;
 246         pDataPackage->MsgData.OutSubmit.CallBackNumber.NumberPlan = Paramcallback.numplan;
 247         pDataPackage->MsgData.OutSubmit.CallBackNumber.szAddrLength = Paramcallback.len;
 248         memcpy(pDataPackage->MsgData.OutSubmit.CallBackNumber.szAddress, Paramcallback.CHARi, Paramcallback.len);
 249 #endif
 250         //1 User Date
 251         msgTxt[msg_len - 1] = '\0';
 252         EncodeCdmaSmsParamUserData(msgTxt, &ParamUser);
 253         pDataPackage->ParamMask |= SMS_PARAM_USER_DATA_MASK;
 254         pDataPackage->MsgData.OutSubmit.MsgEncoding = ParamUser.encoding;
 255         pDataPackage->MsgData.OutSubmit.MsgLength = ParamUser.len;
 256         memcpy(pDataPackage->MsgData.OutSubmit.szData, ParamUser.CHARi, ParamUser.len);
 257
 258         msg("");
 259         msg("=============== Test App Message =================");
 260         msg(" - MsgType: %d", pDataPackage->MsgType);
 261         msg(" - ParamMask: 0x%08x", pDataPackage->ParamMask);
 262         printf("0000: ");
 263         for (i = 0; i < sizeof(TelSmsMsgInfo_t); i++) {
 264                 printf("%02x ", *(((unsigned char *) pDataPackage) + i));
 265                 if ((i + 1) % 8 == 0)
 266                 printf("  ");
 267
 268                 if ((i + 1) % 16 == 0)
 269                 printf("\n%04x: ", i+1);
 270         }
 271         printf("\n");
 272         fflush(stdout);
 273
 274         msg("==============================================");
 275
 276         returnStatus = tel_send_sms_msg(pDataPackage, 0x26, &requestId); //more to send is false since it is not concatenated.for concatenated send 1
 277
 278         msg("tel_send_sms_msg() requestId: %d", requestId);
 279
 280         free(pDataPackage);
 281
 282 #endif
 283         return TRUE;
 284 }
 285
 286 static BOOL DecodeCellBroadcastMsg (int length, char * pPDU)
 287 {
 288         int msgLength;
 289         int sn = 0; //serial number
 290         int msgID; //message identifier
 291         Sms_coding_scheme dcs;
 292
 293         unsigned char page[2];
 294         int contents_length;
 295         char contents[SMS_CB_SIZE_MAX];
 296
 297         unsigned char gs;
 298         unsigned char msgCode;
 299         unsigned char updateNumber;
 300
 301         if (pPDU == NULL ) {
 302                 msg("pData is Null")
 303                 return FALSE;
 304         }
 305
 306         msg("cb msg type is %x", pPDU[0]);
 307         msg("cb msg len is %x", pPDU[1]);
 308
 309         msg("$$$$$$$$$$$$$$$length of cb msg is %d", length);
 310         sn = (pPDU[2] << 8) | pPDU[1];
 311
 312         gs = (pPDU[2] & 0xC0) >> 6;  //bit 7, bit 6
 313
 314         msgCode = ( ( (pPDU[2] & 0x3F) << 4) | pPDU[3]) & 0xF0;
 315
 316         updateNumber = pPDU[3] & 0x0F;  //bit3, bit2, bit1, bit0
 317
 318         msgID = pPDU[4] << 4 | pPDU[3];
 319
 320         SmsUtilDecodeDCS (&dcs, pPDU[6]);
 321
 322         page[0] = pPDU[7] & 0x0F; //total page
 323         page[1] = (pPDU[7] & 0xF0) >> 4; //current page
 324
 325         msgLength = length - 2;
 326
 327         contents_length = msgLength - 6;
 328
 329         if (dcs.alphabet_type == SMS_ALPHABET_DEFAULT) {
 330                 unsigned char inData[SMS_CB_SIZE_MAX + 1];
 331
 332                 memset (inData, 0x00, SMS_CB_SIZE_MAX + 1);
 333
 334                 memcpy ((void*) inData, (void*) &pPDU[8], contents_length);
 335                 SmsUtilUnpackGSMCode (contents, &pPDU[8], msgLength);
 336         }
 337         else {
 338                 memcpy (contents, &pPDU[8], msgLength);
 339                 contents[msgLength] = 0;
 340         }
 341
 342         printf ("*************************************\n");
 343         printf ("serical number : 0x%04x \n", sn);
 344         printf ("Geographical Scope: 0x%x\n", gs);
 345         printf ("message code : 0x%x\n", msgCode);
 346         printf ("update Number : 0x%x\n", updateNumber);
 347         printf ("message identifier :  0x%x\n", msgID);
 348         printf ("DCS-Commpressed?: %d (1: true)\n", dcs.bCompressed);
 349         printf ("DCS-coding_group_type:  %x\n", dcs.coding_group_type);
 350         printf ("contents bytes size : %d\n", contents_length);
 351         printf ("page : (%d /%d) (page /total ) \n", page[1], page[0]);
 352         printf ("contents: %s\n", contents);
 353         printf ("*************************************\n");
 354
 355         return TRUE;
 356 }
 357
 358 static BOOL EncodeSmsSubmitTpdu (MManager *mm, char* diallingNum,
 359                 int dialNumLen, char* msg, int msg_len)
 360 {
 361         TapiHandle *handle = menu_manager_ref_user_data (mm);
 362
 363         TPDU_SMS_SUBMIT tpdu_submit;
 364
 365         unsigned char packet[TAPI_NETTEXT_MSG_SIZE_MAX];
 366
 367         unsigned char SCA[TAPI_NETTEXT_SCADDRESS_LEN_MAX + 1];
 368         int ret = 0;
 369
 370         //      unsigned char tp_mr = 0x03;
 371         tp_mr++;
 372         unsigned char tp_pid = 0; //reaplace type (65)
 373         unsigned char tp_dcs; //=17; //class_1(17),class_2(18)
 374         unsigned char tp_vp;
 375
 376         int index = 0, ScIndex = 0;
 377         int i;
 378         int requestId = 0;
 379         unsigned char sca_len = 0;
 380         TapiResult_t returnStatus;
 381
 382         TelSmsDatapackageInfo_t *pDataPackage = NULL;
 383
 384         memset (packet, 0, TAPI_NETTEXT_MSG_SIZE_MAX);
 385
 386         /************SCA ADDRESS GET START**************/
 387         /*
 388          returnStatus = TelTapiSmsGetSCA(&sc_addr,0);
 389          printf("Service center addr returned from TAPI SCA address %s returnStatus %d\n",sc_addr.szDiallingNum,returnStatus);
 390          SmsUtilDecodeAddrField(decodeScaAddr, &sc_addr.szDiallingNum[0],&sc_addr.Ton, &sc_addr.Npi);
 391          sca_len = strlen( decodeScaAddr );
 392
 393          memcpy( SCA, decodeScaAddr, sca_len);
 394          SCA[sca_len] = '\0';
 395          */
 396         msg("Enter SCA: ");
 397         memset (SCA, 0, sizeof (SCA));
 398
 399         ret = read (0, SCA, sizeof (SCA) - 1);
 400         if (ret <= 0) {
 401                 msg(" NULL msg can NOT be sent ");
 402                 return -1;
 403         }
 404         SCA[ret] = '\0';
 405
 406         pDataPackage = malloc (sizeof(TelSmsDatapackageInfo_t));
 407         memset (pDataPackage, 0, sizeof(TelSmsDatapackageInfo_t));
 408
 409         sca_len = strlen ((char *) SCA) - 1;
 410
 411         msg("Decode SCA Address =========");
 412         msg("SCA Number :%s, SCA Length :%d ", SCA, sca_len);
 413         msg("========================");
 414
 415         //SCA ADDRESS GET END
 416
 417         //SCA
 418
 419         //TODO : SCA
 420
 421         //      index +=SmsUtilEncodeAddrField(packet,SCA, strlen(SCA)  ,0x01,0x01);
 422         ScIndex = SmsUtilEncodeAddrField ((unsigned char*) pDataPackage->Sca,
 423                         (char *) SCA, sca_len, 0x01, 0x01);
 424
 425         msg("ScIndex is %d", ScIndex);
 426
 427         // TP-MTI, TP-RD, TP-VPF, TP-SRR, TP_UDHI, TP-RP
 428         tpdu_submit.msg_type = SMS_TPDU_SUBMIT;
 429         tpdu_submit.rd = FALSE; //false :accept duplicate msg , true: reject duplicate msg
 430         tpdu_submit.vpf = SMS_VP_RELATIVE;
 431         tpdu_submit.srr = FALSE; //false :A status report is not requested , true: A status report is requested
 432         tpdu_submit.udhi = FALSE; //false: contains only the short message , true :a Header in addition to the short message
 433         tpdu_submit.rp = FALSE; //false :TP Reply Path parameter is not set in this SMS SUBMIT, true : TP Reply Path parameter is set in this SMS SUBMIT
 434
 435         packet[index] = tpdu_submit.msg_type;                                   // SUBMIT: bits 0, 1
 436         packet[index] |= tpdu_submit.rd ? 0x04 : 0;                                             // bit 2
 437         packet[index] |= tpdu_submit.vpf << 3;  // bits 3, 4
 438         packet[index] |= tpdu_submit.srr ? 0x20 : 0;                                            // bit 5
 439         packet[index] |= tpdu_submit.udhi ? 0x40 : 0;                                           // bit 6
 440         packet[index] |= tpdu_submit.rp ? 0x80 : 0;                                             // bit 7
 441
 442         index++;
 443         msg("index of message ref is %d, msgref is %d", index, tp_mr);
 444         /* TP-MR */
 445         packet[index++] = tp_mr;
 446
 447         // TP-DA
 448         index += SmsUtilEncodeAddrField (packet + index, diallingNum, dialNumLen,
 449                         0x02, 0x01);
 450
 451         //msg("DESTINATTION  ADDR Encoded =========");
 452
 453         //TP-PID
 454         packet[index++] = tp_pid;
 455
 456         // TP_DCS (Data Coding Scheme)
 457
 458         tpdu_submit.dcs.bCompressed = FALSE;
 459         tpdu_submit.dcs.bmsg_class_set = TRUE;
 460         tpdu_submit.dcs.coding_group_type = SMS_CODGRP_SM_GENERAL_DCS;
 461         tpdu_submit.dcs.alphabet_type = SMS_ALPHABET_DEFAULT;
 462         tpdu_submit.dcs.class_type = SMS_CLASS_2;
 463
 464         SmsUtilEncodeDCS (&tp_dcs, &tpdu_submit.dcs);
 465
 466         packet[index++] = tp_dcs;
 467
 468         //msg("DCS Encoded:tp_dcs =%d =========",tp_dcs);
 469
 470         //TP-VP
 471
 472         tpdu_submit.vp.vp_rel_type = SMS_VP_REL_6H;
 473         tpdu_submit.vp.vp_type = SMS_VP_RELATIVE;
 474         tpdu_submit.vp.vpValue = 0xff;
 475
 476         SmsUtilEncodeValidity (&tp_vp, &tpdu_submit.vp);
 477
 478         //tp_vp =65;
 479         packet[index++] = tp_vp;
 480         //msg("Validity Encoded :tp_vp =%d =========",tp_vp);
 481
 482         // UDL
 483         packet[index++] = msg_len;
 484
 485         // TP-UD
 486
 487         if (tpdu_submit.dcs.alphabet_type == SMS_ALPHABET_DEFAULT) {
 488                 int pos;
 489                 pos = SmsUtilPackGSMCode (packet + index, msg, msg_len);
 490                 index += pos;
 491         }
 492
 493         msg("Send packet to phonseSever[%d] -----", index);
 494
 495         for (i = 0; i < index; i++) {
 496                 msg("[%02x]", packet[i]);
 497                 if (i % 10 == 9)
 498                         msg("\n");
 499         }
 500         msg("\n");
 501
 502         memcpy (pDataPackage->szData, packet, index);
 503         pDataPackage->MsgLength = index;
 504
 505         msg("***Sending the Message (Api:SendMsg)***");
 506
 507         msg("Length : %d", pDataPackage->MsgLength);
 508
 509         returnStatus = tel_send_sms (handle, pDataPackage, 0, on_resp_send_msg,
 510                         NULL );
 511
 512         msg("SendMsg : returnStatus=%d requestId=%d", returnStatus, requestId);
 513
 514         free (pDataPackage);
 515
 516         return TRUE;
 517
 518 #if 0
 519         TPDU_SMS_SUBMIT tpdu_submit;
 520         unsigned char entered_SCA[SMS_SCADDRESS_LEN_MAX]; //send SMS �Ҷ� ����ϴ� ���� SCA��
 521         int ret = 0;
 522
 523         //      unsigned char tp_mr = 0x03;
 524         tp_mr++;
 525         unsigned char tp_pid = 0;//reaplace type (65)
 526         unsigned char tp_dcs;//=17; //class_1(17),class_2(18)
 527         unsigned char tp_vp;
 528
 529         int index = 0, ScIndex = 0;
 530         int i;
 531         unsigned char sca_len =0;
 532         gboolean returnStatus;
 533
 534         int msgLength = 0; /**< Size of array szData (which is actual TPDU message) */
 535         unsigned char szData[SMS_MSG_SIZE_MAX]; /**<SMS TPDU message */
 536
 537         TelSmsDatapackageInfo_t *pDataPackage= malloc(sizeof(TelSmsDatapackageInfo_t));
 538
 539         memset(pDataPackage, 0, sizeof(TelSmsDatapackageInfo_t));
 540         memset(szData, 0, SMS_MSG_SIZE_MAX);
 541
 542         /************SCA ADDRESS GET START**************/
 543         msg("Enter SCA: ");
 544         memset(entered_SCA,0,sizeof(entered_SCA));
 545
 546         ret = read(0, entered_SCA, sizeof(entered_SCA));
 547
 548         if (ret <= 0) {
 549                 msg(" NULL msg can NOT be sent ");
 550                 return -1;
 551         }
 552
 553         sca_len=strlen((char *)entered_SCA)-1;
 554
 555         msg("Decode SCA Address =========");
 556         msg("SCA Number :%s, SCA Length :%d ",entered_SCA , sca_len);
 557         msg("========================");
 558
 559         //SCA ADDRESS GET END
 560
 561         //SCA
 562         ScIndex =SmsUtilEncodeAddrField((unsigned char*)pDataPackage->Sca ,(char *)entered_SCA, sca_len ,0x01,0x01);
 563
 564         msg("ScIndex is %d", ScIndex);
 565
 566         // TP-MTI, TP-RD, TP-VPF, TP-SRR, TP_UDHI, TP-RP
 567         tpdu_submit.msg_type = SMS_TPDU_SUBMIT;
 568         tpdu_submit.rd =FALSE;//false :accept duplicate msg , true: reject duplicate msg
 569         tpdu_submit.vpf = SMS_VP_RELATIVE;
 570         tpdu_submit.srr = FALSE;//false :A status report is not requested , true: A status report is requested
 571         tpdu_submit.udhi = FALSE;//false: contains only the short message , true :a Header in addition to the short message
 572         tpdu_submit.rp = FALSE;//false :TP Reply Path parameter is not set in this SMS SUBMIT, true : TP Reply Path parameter is set in this SMS SUBMIT
 573
 574         szData[index] = tpdu_submit.msg_type;// SUBMIT: bits 0, 1
 575         szData[index] |= tpdu_submit.rd? 0x04 : 0;// bit 2
 576         szData[index] |= tpdu_submit.vpf << 3;// bits 3, 4
 577         szData[index] |= tpdu_submit.srr ? 0x20 : 0;// bit 5
 578         szData[index] |= tpdu_submit.udhi? 0x40 : 0;// bit 6
 579         szData[index] |= tpdu_submit.rp ? 0x80 : 0;// bit 7
 580
 581         index++;
 582         msg("index of message ref is %d, msgref is %d",index,tp_mr);
 583         /* TP-MR */
 584         szData[index++] = tp_mr;
 585
 586         // TP-DA
 587         index += SmsUtilEncodeAddrField( szData+index, diallingNum, dialNumLen, 0x02, 0x01);
 588
 589         //msg("DESTINATTION  ADDR Encoded =========");
 590
 591         //TP-PID
 592         szData[index++] = tp_pid;
 593
 594         // TP_DCS (Data Coding Scheme)
 595         tpdu_submit.dcs.bCompressed = FALSE;
 596         tpdu_submit.dcs.bmsg_class_set = TRUE;
 597         tpdu_submit.dcs.coding_group_type =SMS_CODGRP_SM_GENERAL_DCS;
 598         tpdu_submit.dcs.alphabet_type = SMS_ALPHABET_DEFAULT;
 599         tpdu_submit.dcs.class_type = SMS_CLASS_2;
 600
 601         SmsUtilEncodeDCS(&tp_dcs, &tpdu_submit.dcs);
 602
 603         szData[index++] = tp_dcs;
 604
 605         //msg("DCS Encoded:tp_dcs =%d =========",tp_dcs);
 606
 607         //TP-VP
 608         tpdu_submit.vp.vp_rel_type = SMS_VP_REL_6H;
 609         tpdu_submit.vp.vp_type = SMS_VP_RELATIVE;
 610         tpdu_submit.vp.vpValue =0xff;
 611
 612         SmsUtilEncodeValidity(&tp_vp,&tpdu_submit.vp);
 613
 614         //tp_vp =65;
 615         szData[index++] = tp_vp;
 616         //msg("Validity Encoded :tp_vp =%d =========",tp_vp);
 617
 618         // UDL
 619         szData[index++] = msg_len;
 620
 621         // TP-UD
 622         if (tpdu_submit.dcs.alphabet_type == SMS_ALPHABET_DEFAULT )
 623         {
 624                 int pos;
 625                 pos =SmsUtilPackGSMCode( szData + index, msg, msg_len);
 626                 index += pos;
 627         }
 628
 629         msg("Send szData to phonseSever[%d] -----", index);
 630
 631         for(i=0; i< index; i++ )
 632         {
 633                 msg("[%02x]", szData[i]);
 634                 if( i%10 == 9)
 635                 msg("\n");
 636         }
 637         msg("\n");
 638
 639         memcpy( pDataPackage->szData, szData, index);
 640         pDataPackage->MsgLength = index;
 641
 642         msg("***Sending the Message (Api:SendMsg)***");
 643         msg("Length : %d", msgLength);
 644
 645         returnStatus = tel_send_sms(handle, pDataPackage, 0, on_resp_send_msg, NULL);
 646
 647         msg("SendMsg : returnStatus=0x%x", returnStatus);
 648
 649         return TRUE;
 650 #endif
 651 }
 652
 653 #if 0
 654 static int DecodeSmsSubmitTpdu(int pdu_len, char * pPDU)
 655 {
 656         TPDU_SMS_SUBMIT tpdu_submit;
 657         unsigned char scaAddr_len =0;
 658         int destAddr_len = 0;
 659         char diallingNum[SMS_ADDRESS_LEN_MAX];
 660         char scaAddr[SMS_SCADDRESS_LEN_MAX]; //service center address
 661         char destAddr[SMS_ADDRESS_LEN_MAX];//destination number
 662         int sca_ton, sca_npi, dest_ton,dest_npi;
 663         int position;
 664
 665         position=0;
 666
 667         /* SCA_ADDR */
 668         memset(diallingNum, 0, sizeof(diallingNum));
 669
 670         SmsUtilDecodeAddrField(diallingNum, &pPDU[position],&sca_ton, &sca_npi);
 671
 672         position+=2;  //include Address-Length, Type of Address
 673
 674         scaAddr_len = strlen( (char *)diallingNum );
 675
 676         if ( scaAddr_len % 2 )
 677         position += scaAddr_len / 2 + 1;
 678         else
 679         position += scaAddr_len / 2;
 680
 681         if ( sca_ton == SMS_TON_INTERNATIONAL )
 682         {
 683                 scaAddr[0] = '+';
 684                 memcpy( &scaAddr[1], diallingNum, scaAddr_len );
 685                 scaAddr[scaAddr_len+1] = '\0';
 686         }
 687         else
 688         {
 689                 memcpy( scaAddr, diallingNum, scaAddr_len );
 690                 scaAddr[scaAddr_len] = '\0';
 691         }
 692
 693         //msg(" sca length: %d , sca # : %s", scaAddr_len, scaAddr);
 694
 695         /* TP-MTI, TP-RD, TP-VPF,  TP-RP, TP_UDHI, TP-SRR */
 696
 697         tpdu_submit.msg_type = SMS_TPDU_SUBMIT;// bit 0,1(Message Type Indicator )
 698         tpdu_submit.rd = ( pPDU[position] & 0x04 ) ? TRUE : FALSE;// bit 2 (Message Type Indicator)
 699         tpdu_submit.vpf =( pPDU[position] & 0x18) >> 3;//  bits 3, 4 ( validity period format)
 700         tpdu_submit.srr=( pPDU[position] & 0x20 ) ? TRUE : FALSE;// bit 5 (Status Report Request)
 701         tpdu_submit.udhi=( pPDU[position] & 0x40 ) ? TRUE : FALSE;// bit 6 (User Data Header Indicator)
 702         tpdu_submit.rp = ( pPDU[position] & 0x80 ) ? TRUE : FALSE;// bit 7 (Reply Path)
 703
 704         position++;
 705
 706         /* TP-MR */
 707         tpdu_submit.mr = pPDU[position];
 708
 709         position++;
 710
 711         /* TP-DA */
 712
 713         memset(diallingNum, 0, sizeof(diallingNum));
 714
 715         SmsUtilDecodeAddrField(diallingNum, &pPDU[position],&dest_ton, &dest_npi);
 716
 717         position+=2;
 718
 719         destAddr_len = strlen( (char*) diallingNum );
 720         if ( destAddr_len % 2 )
 721         position += destAddr_len / 2 + 1;
 722         else
 723         position += destAddr_len / 2;
 724
 725         if ( dest_ton == SMS_TON_INTERNATIONAL )
 726         {
 727                 destAddr[0] = '+';
 728                 memcpy( &destAddr[1], diallingNum, destAddr_len );
 729                 destAddr[destAddr_len+1] = '\0';
 730         }
 731         else
 732         {
 733                 memcpy( destAddr, diallingNum, destAddr_len );
 734                 destAddr[destAddr_len] = '\0';
 735         }
 736         //msg(" dest length: %d , dest # : %s", destAddr_len, destAddr);
 737
 738         tpdu_submit.desAddr.DialNumLen= destAddr_len;
 739         memcpy(tpdu_submit.desAddr.szDiallingNum, destAddr , destAddr_len);
 740         tpdu_submit.desAddr.Npi = dest_npi;
 741         tpdu_submit.desAddr.Ton = dest_ton;
 742
 743         /* TP-PID */
 744
 745         tpdu_submit.pId = pPDU[position];
 746         position++;
 747
 748         /* TP DCS */
 749         SmsUtilDecodeDCS( &tpdu_submit.dcs, pPDU[position] );
 750         position ++;
 751
 752         /* TP VP */
 753         tpdu_submit.vp.vp_type = SMS_VP_RELATIVE;  //temp
 754
 755         if(tpdu_submit.vp.vp_type == SMS_VP_RELATIVE)
 756         {
 757                 tpdu_submit.vp.vpValue = pPDU[position];
 758                 tpdu_submit.vp.vp_rel_type = SMS_VP_REL_1D;
 759                 position++;
 760         }
 761         else if (tpdu_submit.vp.vp_type == SMS_VP_ABSOLUTE || tpdu_submit.vp.vp_type == SMS_VP_ENHANCED)
 762         {
 763                 position += 7;
 764         }
 765
 766         /* TP UDL */
 767         tpdu_submit.udl = pPDU[position];
 768
 769         if ( tpdu_submit.udl> SMS_SMDATA_SIZE_MAX )
 770         tpdu_submit.udl = SMS_SMDATA_SIZE_MAX;
 771
 772         position++;
 773
 774         /* TP UD */
 775         tpdu_submit.userData = malloc( sizeof ( unsigned char ) * ( SMS_SMDATA_SIZE_MAX + 1 ) );
 776
 777         memset(tpdu_submit.userData, 0, sizeof ( unsigned char ) * ( SMS_SMDATA_SIZE_MAX + 1 ) );
 778
 779         if (tpdu_submit.dcs.alphabet_type == SMS_ALPHABET_DEFAULT )
 780         {
 781                 char inData[SMS_SMDATA_SIZE_MAX+1];
 782
 783                 memset( inData, 0x00, SMS_SMDATA_SIZE_MAX + 1 );
 784
 785                 memcpy( (void*) inData, (void*) &pPDU[position], tpdu_submit.udl );
 786
 787                 SmsUtilUnpackGSMCode((char *)tpdu_submit.userData, inData, (unsigned char) tpdu_submit.udl);
 788         }
 789
 790         msg("*************************************");
 791         msg("Msg Type: TPDU_SUBMIT");
 792
 793         if(tpdu_submit.rd)
 794         {
 795                 msg("RD: Reject Duplicate")
 796         }
 797
 798         else if(!tpdu_submit.rd)
 799         {
 800                 msg("RD: Accept Duplicate")
 801         }
 802
 803         if(tpdu_submit.srr)
 804         {
 805                 msg("SRR: A status report is requested")
 806         }
 807
 808         else if(!tpdu_submit.srr)
 809         {
 810                 msg("SRR: A status report is not  requested")
 811         }
 812
 813         if(tpdu_submit.udhi)
 814         {
 815                 msg("UDHI: Contains a Header in addition to the short message.")
 816         }
 817         else if(!tpdu_submit.udhi)
 818         {
 819                 msg("UDHI: Only Short Message")
 820         }
 821
 822         if(tpdu_submit.rp)
 823         {
 824                 msg("RP: Set Reply Path")
 825         }
 826
 827         else if(!tpdu_submit.rp)
 828         {
 829                 msg("RP: Not set Reply Path")
 830         }
 831
 832         msg("SCA Addr : %s",scaAddr);
 833         msg("To : %s" ,destAddr);
 834         msg("Message : %s " , tpdu_submit.userData);
 835         msg("*************************************");
 836
 837         return TRUE;
 838 }
 839 #endif
 840
 841 static int DecodeSmsDeliverTpdu (int tpdu_len, char* pTPDU)
 842 {
 843         TPDU_SMS_DELIVER tpdu_deliver;
 844         TmDateTime SCTimeStamp;
 845         ;
 846         int orgAddr_len = 0;
 847         char diallingNum[SMS_ADDRESS_LEN_MAX + 1];
 848         char orgAddr[SMS_ADDRESS_LEN_MAX + 1]; //originating number
 849         int org_ton, org_npi;
 850         int position = 0;
 851
 852         /* TP-MTI, TP-MMS, TP-SRI, TP_UDHI, TP-RP */
 853         tpdu_deliver.msg_type = SMS_TPDU_DELIVER;
 854         tpdu_deliver.mms = (pTPDU[position] & 0x04) ? TRUE : FALSE; // bit 2 (Message Type Indicator)
 855         tpdu_deliver.sri = (pTPDU[position] & 0x20) ? TRUE : FALSE;     // bit 5 (Status Report Indication)
 856         tpdu_deliver.udhi = (pTPDU[position] & 0x40) ? TRUE : FALSE;// bit 6 (User Data Header Indicator)
 857         tpdu_deliver.rp = (pTPDU[position] & 0x80) ? TRUE : FALSE;// bit 7 (Reply Path)
 858
 859         position++;
 860
 861         /* TP-OA */
 862
 863         memset (diallingNum, 0, sizeof (diallingNum));
 864
 865         orgAddr_len = SmsUtilDecodeAddrField (diallingNum, &pTPDU[position],
 866                         &org_ton, &org_npi);
 867         if (orgAddr_len > SMS_ADDRESS_LEN_MAX - 1)
 868                 orgAddr_len = SMS_ADDRESS_LEN_MAX - 1;
 869
 870         position += 2;
 871
 872         if (orgAddr_len % 2)
 873                 position += orgAddr_len / 2 + 1;
 874         else
 875                 position += orgAddr_len / 2;
 876
 877         msg("pos = %d, length = %d", position, orgAddr_len);
 878
 879         if (org_ton == SMS_TON_INTERNATIONAL) {
 880                 orgAddr[0] = '+';
 881                 memcpy (&orgAddr[1], diallingNum, orgAddr_len - 1);
 882                 orgAddr[orgAddr_len + 1] = '\0';
 883         }
 884         else {
 885                 memcpy (orgAddr, diallingNum, orgAddr_len);
 886                 orgAddr[orgAddr_len] = '\0';
 887         }
 888
 889         /* TP-PID */
 890         tpdu_deliver.pId = pTPDU[position];
 891
 892         position++;
 893
 894         /* TP-DCS */
 895         SmsUtilDecodeDCS (&tpdu_deliver.dcs, pTPDU[position]);
 896         dcs_pos = position;
 897         position++;
 898
 899         /* TP-SCTS */
 900         SmsUtilDecodeTimeStamp (&pTPDU[position], &SCTimeStamp);
 901
 902         position += 7;
 903
 904         /* TP-UDL */
 905         tpdu_deliver.udl = pTPDU[position];
 906
 907         if (tpdu_deliver.udl > SMS_SMDATA_SIZE_MAX)
 908                 tpdu_deliver.udl = SMS_SMDATA_SIZE_MAX;
 909
 910         position++;
 911
 912         /* TP-UD */
 913         tpdu_deliver.userData = malloc (
 914                         sizeof(unsigned char) * (SMS_SMDATA_SIZE_MAX + 1));
 915
 916         memset (tpdu_deliver.userData, 0,
 917                         sizeof(unsigned char) * (SMS_SMDATA_SIZE_MAX + 1));
 918
 919         if (tpdu_deliver.dcs.alphabet_type == SMS_ALPHABET_DEFAULT) {
 920                 char inData[SMS_SMDATA_SIZE_MAX + 1];
 921
 922                 memset (inData, 0x00, SMS_SMDATA_SIZE_MAX + 1);
 923
 924                 memcpy ((void*) inData, (void*) &pTPDU[position], tpdu_deliver.udl);
 925
 926                 SmsUtilUnpackGSMCode (tpdu_deliver.userData, inData,
 927                                 (unsigned char) tpdu_deliver.udl);
 928         }
 929
 930         msg("*************************************");
 931         msg("Msg Type: TPDU_DELIVER");
 932
 933         if (tpdu_deliver.rp) {
 934                 msg("RP: Set Reply Path")
 935         }
 936         else if (!tpdu_deliver.rp) {
 937                 msg("RP: Not set Reply Path")
 938         }
 939
 940         if (tpdu_deliver.sri) {
 941                 msg("SRI: A status report shall be returned to the SME")
 942         }
 943         else if (!tpdu_deliver.sri) {
 944                 msg("SRI: A status report shall be not returned to the SME")
 945         }
 946
 947         if (tpdu_deliver.mms) {
 948                 msg("MMS: No more messages are waiting for the MS in this SC")
 949         }
 950         else if (!tpdu_deliver.mms) {
 951                 msg("MMS: More messages are waiting for the MS in this SC")
 952         }
 953
 954         if (tpdu_deliver.udhi) {
 955                 msg("UDHI: Contains a Header in addition to the short message.")
 956         }
 957         else if (!tpdu_deliver.udhi) {
 958                 msg("UDHI: Only short message.")
 959         }
 960
 961         msg("DcsClass : %x (4 means Class None) ", tpdu_deliver.dcs.class_type);
 962
 963         msg("From : %10s", orgAddr);
 964         msg("Time : %d-%d-%d  , %d:%d:%d", SCTimeStamp.year, SCTimeStamp.month,
 965                         SCTimeStamp.day, SCTimeStamp.hour, SCTimeStamp.minute,
 966                         SCTimeStamp.second);
 967         msg("Message : %s ", tpdu_deliver.userData);
 968         msg("*************************************");
 969
 970         return dcs_pos;
 971 }
 972
 973 #if 0
 974 static BOOL EncodeSmsDeliverReportTpdu()
 975 {
 976         TPDU_SMS_DELIVER_REPORT deliver_report;
 977         unsigned char packet[500];
 978         TelSmsDatapackageInfo_t * pDataPackage;
 979         unsigned char tp_dcs;
 980         unsigned char mask=0x69;
 981         int index=0;
 982         int i;
 983
 984         TelSmsDatapackageInfo_t del_report;
 985
 986         memset(&(del_report), 0 , sizeof(TelSmsDatapackageInfo_t));
 987
 988         pDataPackage = malloc(sizeof(TelSmsDatapackageInfo_t));
 989         memset(pDataPackage, 0, sizeof(TelSmsDatapackageInfo_t));
 990
 991         memset(packet, 0, 500);
 992
 993         /* TP-MTI , TP-UDHI */
 994         deliver_report.msg_type = SMS_TPDU_DELIVER_REPORT;
 995         deliver_report.udhi = FALSE;
 996
 997         packet[index] = deliver_report.msg_type;                                        //DELIVER REPORT
 998         packet[index] |= deliver_report.udhi? 0x40 : 0;//bit 6
 999
1000         index ++;
1001
1002         /* TP-FCS */
1003         //if(result==FAIL)
1004         //{
1005
1006         //}
1007
1008         /* TP -PI */
1009         deliver_report.paraInd = mask;
1010         packet[index] = deliver_report.paraInd;
1011
1012         if ( ( mask != 0xFF ) && ( mask != 0 ) )
1013         {
1014                 index++;
1015                 /* TP-PID */
1016                 if ( mask & 0x01)
1017                 {
1018                         deliver_report.pId = 0x65;
1019                         packet[index++] = deliver_report.pId;
1020                 }
1021
1022                 /* TP-DCS */
1023                 if ( mask & 0x02)
1024                 {
1025                         deliver_report.dcs.bCompressed = FALSE;
1026                         deliver_report.dcs.bmsg_class_set = TRUE;
1027                         deliver_report.dcs.coding_group_type =SMS_CODGRP_SM_GENERAL_DCS;
1028                         deliver_report.dcs.alphabet_type = SMS_ALPHABET_DEFAULT;
1029                         deliver_report.dcs.class_type = SMS_CLASS_2;
1030
1031                         SmsUtilEncodeDCS(&tp_dcs, &deliver_report.dcs);
1032                         packet[index++] = tp_dcs;
1033                 }
1034                 /* TP-UDL */
1035                 if ( mask & 0x04)
1036                 {
1037                         deliver_report.udl =0x00;
1038                         packet[index++] = deliver_report.udl;
1039
1040                         /* TP-UD */
1041
1042                         if (deliver_report.dcs.alphabet_type == SMS_ALPHABET_DEFAULT )
1043                         {
1044                                 //SmsUtilPackGSMCode( packet + index, msg, msg_len);
1045                         }
1046                 }
1047         }
1048         msg("EncodeSmsDeliverReportTpdu");
1049         msg("Send packet to phonseSever[%d] -----", index);
1050
1051         for(i=0; i< index; i++ )
1052         {
1053                 msg("[%02x]", packet[i]);
1054                 if( i%10 == 9)
1055                 msg("\n");
1056         }
1057         msg("\n");
1058         memcpy( del_report.szData, packet, index);
1059         del_report.MsgLength = index;
1060         msg("msgLength :%d",del_report.MsgLength);
1061         int requestId =0;
1062         tel_send_sms_deliver_report(&del_report,0, &requestId); //madhavi
1063         msg("after send deliver report request id is %d",requestId);
1064         return TRUE;
1065 }
1066 #endif
1067
1068 #if 0
1069 static BOOL DecodeSmsSubmitReportTpdu(int length , char *data)
1070 {
1071
1072         TPDU_SMS_SUBMIT_REPORT submit_report;
1073         TmDateTime SCTimeStamp;;
1074         int position=1;
1075         int i=0;
1076         unsigned char msgRef, tpdu_len;
1077         int result=0;
1078         unsigned char mask;
1079
1080         /* Result */
1081
1082         if(data == NULL) {
1083                 msg("pData is Null")
1084                 return FALSE;
1085         }
1086
1087         msg("length :%d",length);
1088
1089         for(i=0;i<length;i++)
1090         msg("[%02x]",data[i]);
1091
1092         result = data[position];
1093
1094         msg("In ackrecv (return status) result is %x",result);
1095         position ++;
1096
1097         /* Msg Reference */
1098
1099         msgRef = data[position++];
1100         msg("In ackrecv  position :%d msgref is %x",position,msgRef);
1101         position ++;
1102
1103         /* TPDU Length */
1104
1105         tpdu_len = data[position];
1106         msg("In ackrecv position :%d len is %d",position,tpdu_len);
1107
1108         /**** SUBMIT REPORT TPDU PARSING
1109          ***/
1110
1111         /* TP-MTI , TP-UDHI */
1112         msg("before TPDU position value:%d",position);
1113
1114         submit_report.msg_type = data[position] & 0x03; //bit 0,1
1115         submit_report.udhi = data[position] & 0x40 ? TRUE : FALSE;//bit 6;
1116
1117         position ++;
1118
1119         if(result == FAIL)
1120         {
1121                 /* TP-FCS */
1122                 submit_report.fcs = data[position];
1123                 position ++;
1124         }
1125
1126         /* TP-PI  - set to a 1 indicates that a particular optional parameter is present in the fields which follow. */
1127         /* Masking Bit  - TP -PID (bit 0), TP-DCS(bit 1), TP-UDL(bit 2) */
1128
1129         submit_report.paraInd = data[position];
1130         mask = submit_report.paraInd;
1131         position ++;
1132
1133         //msg("Parmeter Indication mask =%x", mask);
1134
1135         /* TP-SCTS */
1136
1137         SmsUtilDecodeTimeStamp( &data[position], & SCTimeStamp );
1138
1139         position+=7;
1140
1141         if( ( mask != 0xFF ) && ( mask != 0 ) )
1142         {
1143                 /* TP-PID */
1144                 if ( mask & 0x01)
1145                 {
1146                         submit_report.pId= data[position];
1147                         position ++;
1148                         msg("TP-PID :%x", submit_report.pId);
1149                 }
1150
1151                 /* TP-DCS */
1152                 if ( mask & 0x02)
1153                 {
1154                         SmsUtilDecodeDCS( &submit_report.dcs, data[position] );
1155                         position ++;
1156                         msg("TP-DCS :%x",data[position] );
1157                 }
1158
1159                 if ( mask & 0x04)
1160                 {
1161                         /* TP-UDL */
1162                         submit_report.udl = data[position];
1163                         position++;
1164
1165                         msg("TP-UDL :%x",data[position] );
1166
1167                         /* TP-UD */
1168
1169                         submit_report.userData = malloc( sizeof ( unsigned char ) * ( SMS_SMDATA_SIZE_MAX + 1 ) );
1170
1171                         memset(submit_report.userData, 0, sizeof ( unsigned char ) * ( SMS_SMDATA_SIZE_MAX + 1 ) );
1172
1173                         if (submit_report.dcs.alphabet_type == SMS_ALPHABET_DEFAULT )
1174                         {
1175                                 char inData[SMS_SMDATA_SIZE_MAX+1];
1176
1177                                 memset( inData, 0x00, SMS_SMDATA_SIZE_MAX + 1 );
1178
1179                                 memcpy( (void*) inData, (void*) &data[position], submit_report.udl );
1180
1181                                 SmsUtilUnpackGSMCode(submit_report.userData, inData, (unsigned char) submit_report.udl);
1182                         }
1183
1184                 }
1185         }
1186
1187         msg("*************************************");
1188
1189         if(result != 0x00)
1190         msg("SMS SEND FAIL!!")
1191         else
1192         msg("SMS SEND SUCCESS!!")
1193
1194         if(result != 0x00)
1195         msg("Failure Code : %x",submit_report.fcs)
1196
1197         msg("*************************************");
1198
1199         return TRUE;
1200 }
1201 #endif
1202
1203 static int DecodeSmsStatusReportTpdu (int tpdu_len, char* pTPDU)
1204 {
1205         TPDU_SMS_STATUS_REPORT status_report;
1206
1207         TmDateTime SCTimeStamp;
1208         TmDateTime DischargeTime;
1209
1210         int rcpAddr_len = 0;
1211         char diallingNum[SMS_ADDRESS_LEN_MAX];
1212
1213         char rcpAddr[SMS_ADDRESS_LEN_MAX]; //recipient number
1214         int rcp_ton, rcp_npi;
1215         int position = 0;
1216         unsigned int mask;
1217
1218         /* TP-MTI, TP MMS, TP SRQ, TP_UDHI */
1219
1220         status_report.msg_type = pTPDU[position] & 0x03; // bit 0,1
1221         status_report.mms = pTPDU[position] & 0x04 ? TRUE : FALSE; // bit 2
1222         status_report.srq = pTPDU[position] & 0x20 ? TRUE : FALSE; //bit 5
1223         status_report.udhi = pTPDU[position] & 0x40 ? TRUE : FALSE;      //bit 6
1224
1225         position++;
1226
1227         /* TP-MR */
1228         status_report.mr = pTPDU[position];
1229         position++;
1230
1231         /* TP-RA */
1232
1233         memset (diallingNum, 0, sizeof (diallingNum));
1234
1235         SmsUtilDecodeAddrField (diallingNum, &pTPDU[position], &rcp_ton, &rcp_npi);
1236
1237         position += 2;
1238
1239         rcpAddr_len = strlen ((char*) diallingNum);
1240         if (rcpAddr_len % 2)
1241                 position += rcpAddr_len / 2 + 1;
1242         else
1243                 position += rcpAddr_len / 2;
1244
1245         if (rcp_ton == SMS_TON_INTERNATIONAL) {
1246                 rcpAddr[0] = '+';
1247                 memcpy (&rcpAddr[1], diallingNum, rcpAddr_len);
1248                 rcpAddr[rcpAddr_len + 1] = '\0';
1249         }
1250         else {
1251                 memcpy (rcpAddr, diallingNum, rcpAddr_len);
1252                 rcpAddr[rcpAddr_len] = '\0';
1253         }
1254
1255         status_report.rcpAddr.DialNumLen = rcpAddr_len;
1256         memcpy (status_report.rcpAddr.szDiallingNum, rcpAddr, rcpAddr_len);
1257         status_report.rcpAddr.Npi = rcp_npi;
1258         status_report.rcpAddr.Ton = rcp_ton;
1259
1260         /* TP-SCTS */
1261         SmsUtilDecodeTimeStamp (&pTPDU[position], &SCTimeStamp);
1262         position += 7;
1263
1264         /* TP-DT */
1265         SmsUtilDecodeTimeStamp (&pTPDU[position], &DischargeTime);
1266         position += 7;
1267
1268         /* TP-ST */
1269         status_report.status = pTPDU[position];
1270         position++;
1271
1272         /* TP-PI */
1273         status_report.paraInd = pTPDU[position];
1274
1275         mask = status_report.paraInd;
1276
1277         if ( (mask != 0xFF) && (mask != 0)) {
1278                 /* Increment only if mask is valid */
1279                 position++;
1280
1281                 /* TP-PID */
1282                 if (mask & 0x01) {
1283                         status_report.pId = pTPDU[position];
1284                         position++;
1285                 }
1286                 /* TP-DCS */
1287                 if (mask & 0x02) {
1288                         SmsUtilDecodeDCS (&status_report.dcs, pTPDU[position]);
1289                         position++;
1290                 }
1291                 if (mask & 0x04) {
1292                         /* TP-UDL */
1293                         status_report.udl = pTPDU[position];
1294                         position++;
1295
1296                         /* TP-UD */
1297
1298                         status_report.userData = malloc (
1299                                         sizeof(unsigned char) * (SMS_SMDATA_SIZE_MAX + 1));
1300
1301                         memset (status_report.userData, 0,
1302                                         sizeof(unsigned char) * (SMS_SMDATA_SIZE_MAX + 1));
1303
1304                         if (status_report.dcs.alphabet_type == SMS_ALPHABET_DEFAULT) {
1305                                 char inData[SMS_SMDATA_SIZE_MAX + 1];
1306
1307                                 memset (inData, 0x00, SMS_SMDATA_SIZE_MAX + 1);
1308
1309                                 memcpy ((void*) inData, (void*) &pTPDU[position],
1310                                                 status_report.udl);
1311
1312                                 SmsUtilUnpackGSMCode (status_report.userData, inData,
1313                                                 (unsigned char) status_report.udl);
1314                         }
1315
1316                 }
1317         }
1318
1319         msg("*************************************");
1320         msg("Msg Type: STATUS_REPORT");
1321         if (status_report.mms) {
1322                 msg("MMS: No more messages are waiting for the MS in this SC")
1323         }
1324         else if (!status_report.mms) {
1325                 msg("MMS: More messages are waiting for the MS in this SC")
1326         }
1327
1328         if (status_report.srq) {
1329                 msg("SRQ: the result of an SMS COMMAND ")
1330         }
1331         else if (!status_report.srq) {
1332                 msg("SRQ: the result of a SMS SUBMIT.")
1333         }
1334
1335         if (status_report.udhi) {
1336                 msg("UDHI: Contains a Header in addition to the short message.")
1337         }
1338         else if (!status_report.udhi) {
1339                 msg("UDHI: Only Short Message")
1340         }
1341
1342         msg("STATUS:%x", status_report.status);
1343         if (status_report.status == 0x00) {
1344                 msg("STATUS : Short message received by the SME")
1345         }
1346         else if (status_report.status == 0x01) {
1347                 msg(
1348                                 "STATUS : Short message forwarded by the SC to the SMEbut the SC is unable to confirm delivery")
1349         }
1350         else if (status_report.status == 0x02) {
1351                 msg("STATUS : Short message replaced by the SC")
1352         }
1353
1354         msg("Recipient Number : %s", rcpAddr);
1355         msg("SC Time Stamp : %d-%d-%d  , %d:%d:%d", SCTimeStamp.year,
1356                         SCTimeStamp.month, SCTimeStamp.day, SCTimeStamp.hour,
1357                         SCTimeStamp.minute, SCTimeStamp.second);
1358         msg("Discharge Time : %d-%d-%d  , %d:%d:%d", DischargeTime.year,
1359                         DischargeTime.month, DischargeTime.day, DischargeTime.hour,
1360                         DischargeTime.minute, DischargeTime.second);
1361
1362         if (mask & 0x04)
1363                 msg("Message : %s ", status_report.userData);
1364
1365         msg("*************************************");
1366
1367         return 1;
1368 }
1369
1370 static void on_noti_sms_incom_msg (TapiHandle *handle, const char *noti_id,
1371                 void *data, void *user_data)
1372 {
1373         int scaAddr_len = 0;
1374         char * pTPDU;
1375         int tpdu_len = 0;
1376         char diallingNum[TAPI_NETTEXT_ADDRESS_LEN_MAX + 1] = { 0, };
1377         char scaAddr[TAPI_NETTEXT_SCADDRESS_LEN_MAX + 2] = { 0, }; //service center address
1378         int sca_ton, sca_npi;
1379         int position;
1380
1381         unsigned char MTI = 0;
1382         unsigned char MMS = 0;
1383         unsigned char SRI = 0;
1384         unsigned char UDHI = 0;
1385         unsigned char RP = 0;
1386
1387         Sms_coding_scheme dcs;
1388         TelSmsDatapackageInfo_t * datapackage;
1389         TapiResult_t returnStatus;
1390         position = 0;
1391
1392         msg("");
1393         msgb("event(%s) receive !!", TAPI_NOTI_SMS_INCOM_MSG);
1394
1395         if (data == NULL ) {
1396                 msg("data is Null")
1397                 return;
1398         }
1399
1400         datapackage = (TelSmsDatapackageInfo_t *) data;
1401
1402         memset (diallingNum, 0, sizeof (diallingNum));
1403
1404         SmsUtilDecodeAddrField (diallingNum, (char *) datapackage->Sca, &sca_ton,
1405                         &sca_npi);
1406
1407         scaAddr_len = strlen (diallingNum);
1408         if (scaAddr_len > TAPI_NETTEXT_SCADDRESS_LEN_MAX)
1409                 scaAddr_len = TAPI_NETTEXT_SCADDRESS_LEN_MAX;
1410
1411         if (sca_ton == SMS_TON_INTERNATIONAL) {
1412                 scaAddr[0] = '+';
1413                 memcpy (&scaAddr[1], diallingNum, scaAddr_len - 1);
1414         }
1415         else {
1416                 memcpy (scaAddr, diallingNum, scaAddr_len);
1417         }
1418
1419         msg("Sc address in test app is %s", scaAddr);
1420
1421         RP = datapackage->szData[position] & 0x80;
1422         UDHI = datapackage->szData[position] & 0x40;
1423         SRI = datapackage->szData[position] & 0x20;
1424         MMS = datapackage->szData[position] & 0x04;
1425         MTI = datapackage->szData[position] & 0x03;
1426
1427         msg("RP [%x]", RP);
1428         msg("UDHI [%x]", UDHI);
1429         msg("SRI [%x]", SRI);
1430         msg("MMS [%x]", MMS);
1431         msg("MTI [%02x]", MTI);
1432
1433         tpdu_len = datapackage->MsgLength;
1434
1435         pTPDU = malloc (sizeof(unsigned char) * tpdu_len);
1436
1437         memcpy (pTPDU, &datapackage->szData[position], tpdu_len);
1438
1439         if (MTI == SMS_TPDU_DELIVER) {
1440                 DecodeSmsDeliverTpdu (tpdu_len, pTPDU);
1441
1442                 msg("dcs_pos : %d", dcs_pos);
1443
1444                 SmsUtilDecodeDCS (&dcs, datapackage->szData[position + dcs_pos]);
1445
1446                 //if(dcs.class_type == TAPI_NETTEXT_CLASS_2)
1447                 {
1448                         msg("dcs type is of class2");
1449                         TelSmsData_t WriteData;
1450
1451                         memset (&WriteData, 0, sizeof(TelSmsData_t));
1452
1453                         memcpy (WriteData.SmsData.Sca, datapackage->Sca,
1454                                         TAPI_SIM_SMSP_ADDRESS_LEN);
1455
1456                         WriteData.SmsData.MsgLength = datapackage->MsgLength;
1457
1458                         memcpy (WriteData.SmsData.szData, datapackage->szData,
1459                                         datapackage->MsgLength);
1460
1461                         WriteData.MsgStatus = TAPI_NETTEXT_STATUS_READ;
1462
1463                         returnStatus = tel_write_sms_in_sim (handle, &WriteData,
1464                                         on_resp_save_msg, NULL );
1465
1466                         msg("returnStatus for tel_write_sms_in_sim(): 0x%x", returnStatus);
1467                 }
1468
1469         }
1470         else if (MTI == SMS_TPDU_STATUS_REPORT) {
1471                 DecodeSmsStatusReportTpdu (tpdu_len, pTPDU);
1472         }
1473
1474         TelSmsDatapackageInfo_t * del_report = NULL;
1475
1476         del_report = malloc (sizeof(TelSmsDatapackageInfo_t));
1477
1478         memset (del_report, 0, sizeof(TelSmsDatapackageInfo_t));
1479
1480         memcpy (del_report->Sca, datapackage->Sca, TAPI_SIM_SMSP_ADDRESS_LEN);
1481
1482         del_report->szData[0] = SMS_TPDU_DELIVER_REPORT;        //TP-UDHI[bit6] : 0
1483         del_report->szData[1] = 0;// TP-PI = 0; bit2: TP-UDL bit1: TP-DCS bit0: TP-PID (No option field)
1484         del_report->MsgLength = 2;
1485
1486         msg("***receive message (Api:SendDeliverreport)****");
1487
1488         returnStatus = tel_send_sms_deliver_report (handle, del_report,
1489                         TAPI_NETTEXT_SENDSMS_SUCCESS, on_resp_DeliverReport_msg, NULL );
1490
1491         msg("returnStatus for tel_send_sms_deliver_report(): 0x%x", returnStatus);
1492
1493         free (del_report);
1494
1495         free (pTPDU);
1496 }
1497
1498 static void on_noti_sms_cb_incom_msg (TapiHandle *handle, const char *noti_id,
1499                 void *data, void *user_data)
1500 {
1501         TelSmsCbMsg_t *cbMsg = data;
1502         int length = 0;
1503         char pPDU[SMS_CB_SIZE_MAX + 3] = { 0, };
1504
1505         msg("");
1506         msgb("event(%s) receive !!", TAPI_NOTI_SMS_CB_INCOM_MSG);
1507
1508         length = cbMsg->Length;
1509         pPDU[0] = cbMsg->CbMsgType;
1510         pPDU[1] = length;
1511         memcpy (& (pPDU[2]), cbMsg->szMsgData, SMS_CB_SIZE_MAX + 1);
1512
1513         DecodeCellBroadcastMsg (length, pPDU);
1514 }
1515
1516 static void on_noti_sms_etws_incom_msg (TapiHandle *handle, const char *noti_id,
1517                 void *data, void *user_data)
1518 {
1519         TelSmsEtwsMsg_t *etwsMsg = data;
1520         int length = 0;
1521         char pPDU[TAPI_NETTEXT_ETWS_SIZE_MAX + 3] = { 0, };
1522
1523         msg("");
1524         msgb("event(%s) receive !!", TAPI_NOTI_SMS_ETWS_INCOM_MSG);
1525
1526         length = etwsMsg->Length;
1527         pPDU[0] = etwsMsg->EtwsMsgType;
1528         pPDU[1] = length;
1529         memcpy (& (pPDU[2]), etwsMsg->szMsgData, TAPI_NETTEXT_ETWS_SIZE_MAX + 1);
1530 }
1531
1532 #if 0
1533 static void on_noti_sms_incom_ex_msg(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
1534 {
1535         tel_service_object_get_int(notiObj, "ParamMask");
1536         tel_service_object_get_int(notiObj, "MsgType");
1537
1538         switch(tel_service_object_get_int(notiObj, "MsgType"))
1539         {
1540                 case MESSAGETYPE_DELIVER:
1541                         /* Origination address */
1542                         tel_service_object_get_int(notiObj, "OrigAddr.Digit");
1543                         tel_service_object_get_int(notiObj, "OrigAddr.NumberMode");
1544                         tel_service_object_get_int(notiObj, "OrigAddr.NumberType");
1545                         tel_service_object_get_int(notiObj, "OrigAddr.NumberPlan");
1546                         tel_service_object_get_char(notiObj, "OrigAddr.szAddrLength");
1547                         tel_service_object_get_string(notiObj, "OrigAddr.szAddress");
1548
1549                         /* Origination subaddress */
1550                         tel_service_object_get_int(notiObj, "OrigSubAddr.SubType");
1551                         tel_service_object_get_char(notiObj, "OrigSubAddr.Odd");
1552                         tel_service_object_get_char(notiObj, "OrigSubAddr.szAddrLength");
1553                         tel_service_object_get_string(notiObj, "OrigSubAddr.szAddress");
1554
1555                         tel_service_object_get_int(notiObj, "TeleService");
1556                         tel_service_object_get_int(notiObj, "bBearerReplySeqRequest");
1557                         tel_service_object_get_char(notiObj, "ReplySeqNumber");
1558                         tel_service_object_get_int(notiObj, "MsgId");
1559                         tel_service_object_get_int(notiObj, "MsgEncoding");
1560                         tel_service_object_get_int(notiObj, "MsgLength");
1561                         tel_service_object_get_string(notiObj, "szData");
1562
1563                         /* Message center time stamp */
1564                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.year");
1565                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.month");
1566                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.day");
1567                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.hours");
1568                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.minutes");
1569                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.seconds");
1570
1571                         /* Validity period - Absolute */
1572                         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.year");
1573                         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.month");
1574                         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.day");
1575                         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.hours");
1576                         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.minutes");
1577                         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.seconds");
1578
1579                         tel_service_object_get_char(notiObj, "ValidityPeriodRel");
1580
1581                         /* Deferred delivery time - Absolute (not supported) */
1582                         tel_service_object_get_int(notiObj, "DeferredDelTimeAbs.year");
1583                         tel_service_object_get_int(notiObj, "DeferredDelTimeAbs.month");
1584                         tel_service_object_get_int(notiObj, "DeferredDelTimeAbs.day");
1585                         tel_service_object_get_int(notiObj, "DeferredDelTimeAbs.hours");
1586                         tel_service_object_get_int(notiObj, "DeferredDelTimeAbs.minutes");
1587                         tel_service_object_get_int(notiObj, "DeferredDelTimeAbs.seconds");
1588
1589                         /* Deferred delivery time - Relative (not supported) */
1590                         tel_service_object_get_char(notiObj, "DeferredDelTimeRel");
1591
1592                         tel_service_object_get_int(notiObj, "Priority");
1593                         tel_service_object_get_int(notiObj, "Privacy");
1594                         tel_service_object_get_char(notiObj, "NumMsg");
1595                         tel_service_object_get_int(notiObj, "bUserAckRequest");
1596                         tel_service_object_get_int(notiObj, "bDeliveryAckRequest");
1597                         tel_service_object_get_int(notiObj, "AlertPriority");
1598                         tel_service_object_get_int(notiObj, "MsgLang");
1599
1600                         /* Callback number address */
1601                         tel_service_object_get_int(notiObj, "CallBackNumer.Digit");
1602                         tel_service_object_get_int(notiObj, "CallBackNumer.NumberMode");
1603                         tel_service_object_get_int(notiObj, "CallBackNumer.NumberType");
1604                         tel_service_object_get_int(notiObj, "CallBackNumer.NumberPlan");
1605                         tel_service_object_get_char(notiObj, "CallBackNumer.szAddrLength");
1606                         tel_service_object_get_string(notiObj, "CallBackNumer.szAddress");
1607
1608                         tel_service_object_get_int(notiObj, "Display");
1609
1610                         break;
1611
1612                 case MESSAGETYPE_DELIVERY_ACK:
1613                         /* Origination address */
1614                         tel_service_object_get_int(notiObj, "OrigAddr.Digit");
1615                         tel_service_object_get_int(notiObj, "OrigAddr.NumberMode");
1616                         tel_service_object_get_int(notiObj, "OrigAddr.NumberType");
1617                         tel_service_object_get_int(notiObj, "OrigAddr.NumberPlan");
1618                         tel_service_object_get_char(notiObj, "OrigAddr.szAddrLength");
1619                         tel_service_object_get_string(notiObj, "OrigAddr.szAddress");
1620
1621                         /* Origination subaddress */
1622                         tel_service_object_get_int(notiObj, "OrigSubAddr.SubType");
1623                         tel_service_object_get_char(notiObj, "OrigSubAddr.Odd");
1624                         tel_service_object_get_char(notiObj, "OrigSubAddr.szAddrLength");
1625                         tel_service_object_get_char(notiObj, "OrigSubAddr.szAddress");
1626
1627                         tel_service_object_get_int(notiObj, "TeleService");
1628                         tel_service_object_get_int(notiObj, "bBearerReplySeqRequest");
1629                         tel_service_object_get_char(notiObj, "ReplySeqNumber");
1630                         tel_service_object_get_int(notiObj, "MsgId");
1631                         tel_service_object_get_int(notiObj, "MsgEncoding");
1632                         tel_service_object_get_int(notiObj, "MsgLength");
1633                         tel_service_object_get_string(notiObj, "szData");
1634
1635                         tel_service_object_get_char(notiObj, "UserResponseCode");
1636
1637                         /* Message center time stamp */
1638                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.year");
1639                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.month");
1640                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.day");
1641                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.hours");
1642                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.minutes");
1643                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.seconds");
1644
1645                         break;
1646
1647                 case MESSAGETYPE_USER_ACK:
1648                         /* Origination address */
1649                         tel_service_object_get_int(notiObj, "OrigAddr.Digit");
1650                         tel_service_object_get_int(notiObj, "OrigAddr.NumberMode");
1651                         tel_service_object_get_int(notiObj, "OrigAddr.NumberType");
1652                         tel_service_object_get_int(notiObj, "OrigAddr.NumberPlan");
1653                         tel_service_object_get_char(notiObj, "OrigAddr.szAddrLength");
1654                         tel_service_object_get_string(notiObj, "OrigAddr.szAddress");
1655
1656                         /* Origination subaddress */
1657                         tel_service_object_get_int(notiObj, "OrigSubAddr.SubType");
1658                         tel_service_object_get_char(notiObj, "OrigSubAddr.Odd");
1659                         tel_service_object_get_char(notiObj, "OrigSubAddr.szAddrLength");
1660                         tel_service_object_get_char(notiObj, "OrigSubAddr.szAddress");
1661
1662                         tel_service_object_get_int(notiObj, "TeleService");
1663                         tel_service_object_get_int(notiObj, "bBearerReplySeqRequest");
1664                         tel_service_object_get_char(notiObj, "ReplySeqNumber");
1665                         tel_service_object_get_int(notiObj, "MsgId");
1666                         tel_service_object_get_int(notiObj, "MsgEncoding");
1667                         tel_service_object_get_int(notiObj, "MsgLength");
1668                         tel_service_object_get_string(notiObj, "szData");
1669
1670                         /* Message center time stamp */
1671                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.year");
1672                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.month");
1673                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.day");
1674                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.hours");
1675                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.minutes");
1676                         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.seconds");
1677
1678                         break;
1679                 default:
1680                         break;
1681         }
1682 }
1683 #endif
1684
1685 #if 0
1686 static void on_noti_sms_cb_incom_ex_msg(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
1687 {
1688         tel_service_object_get_string(notiObj, "szData");
1689
1690         /* Message center time stamp */
1691         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.year");
1692         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.month");
1693         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.day");
1694         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.hours");
1695         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.minutes");
1696         tel_service_object_get_int(notiObj, "MessageCenterTimeStamp.seconds");
1697
1698         /* Validity period - Absolute */
1699         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.year");
1700         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.month");
1701         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.day");
1702         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.hours");
1703         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.minutes");
1704         tel_service_object_get_int(notiObj, "ValidityPeriodAbs.seconds");
1705
1706         tel_service_object_get_char(notiObj, "ValidityPeriodRel");
1707
1708         tel_service_object_get_int(notiObj, "Priority");
1709         tel_service_object_get_int(notiObj, "AlertPriority");
1710         tel_service_object_get_int(notiObj, "MsgLang");
1711         tel_service_object_get_int(notiObj, "Display");
1712 }
1713 #endif
1714
1715 static void on_noti_sms_memory_status (TapiHandle *handle, const char *noti_id,
1716                 void *data, void *user_data)
1717 {
1718         int *memory_status = data;
1719
1720         msg("");
1721         msgb("event(%s) receive !!", TAPI_NOTI_SMS_MEMORY_STATUS);
1722         msg(" - memory_status = 0x%x", *memory_status);
1723 }
1724
1725 static void on_noti_sms_ready_status (TapiHandle *handle, const char *noti_id,
1726                 void *data, void *user_data)
1727 {
1728         gboolean *device_ready = data;
1729
1730         msg("");
1731         msgb("event(%s) receive !!", TAPI_NOTI_SMS_DEVICE_READY);
1732         msg(" - device_ready = %s", *device_ready ? "TRUE" : "FALSE");
1733 }
1734
1735 static void on_resp_send_msg (TapiHandle *handle, int result, void *data,
1736                 void *user_data)
1737 {
1738         msg("");
1739         msgb("tel_send_sms() response receive");
1740         msg(" - result = 0x%x", result);
1741 }
1742
1743 static void on_resp_read_msg (TapiHandle *handle, int result, void *data,
1744                 void *user_data)
1745 {
1746         TelSmsData_t * sim_data;
1747         int scaAddr_len = 0;
1748         char * pTPDU;
1749         int tpdu_len = 0;
1750         char diallingNum[TAPI_NETTEXT_ADDRESS_LEN_MAX + 1] = { 0, };
1751         char scaAddr[TAPI_NETTEXT_SCADDRESS_LEN_MAX + 2] = { 0, }; //service center address
1752         int sca_ton, sca_npi;
1753         int position;
1754
1755         if (data == NULL ) {
1756                 msg("data is Null");
1757                 return;
1758         }
1759
1760         sim_data = (TelSmsData_t *) data;
1761
1762         if (sim_data->MsgStatus == TAPI_NETTEXT_STATUS_UNREAD)
1763                 msg("Msg Staus : received unread msg")
1764         else if (sim_data->MsgStatus == TAPI_NETTEXT_STATUS_READ)
1765                 msg("Msg Staus : received read msg")
1766         else if (sim_data->MsgStatus == TAPI_NETTEXT_STATUS_UNSENT)
1767                 msg("Msg Staus : unsent msg")
1768         else
1769                 msg("Msg Staus : [%d]", sim_data->MsgStatus)
1770
1771         msg("First Data [%x]", sim_data->SmsData.szData[0]);
1772         msg("Second Data [%x]", sim_data->SmsData.szData[1]);
1773         msg("Third Data [%x]", sim_data->SmsData.szData[2]);
1774         msg("Fourth Data [%x]", sim_data->SmsData.szData[3]);
1775
1776         position = 0;
1777         // SCA_ADDR
1778         memset (diallingNum, 0, sizeof (diallingNum));
1779
1780         SmsUtilDecodeAddrField (diallingNum, (char *) sim_data->SmsData.Sca,
1781                         &sca_ton, &sca_npi);
1782
1783         position += 2;  //include Address-Length, Type of Address
1784
1785         scaAddr_len = strlen ((char *) diallingNum);
1786         if (scaAddr_len > TAPI_NETTEXT_SCADDRESS_LEN_MAX - 1)
1787                 scaAddr_len = TAPI_NETTEXT_SCADDRESS_LEN_MAX - 1;
1788
1789         if (scaAddr_len % 2)
1790                 position += scaAddr_len / 2 + 1;
1791         else
1792                 position += scaAddr_len / 2;
1793
1794         if (sca_ton == SMS_TON_INTERNATIONAL) {
1795                 scaAddr[0] = '+';
1796                 memcpy (&scaAddr[1], diallingNum, scaAddr_len);
1797         }
1798         else {
1799                 memcpy (scaAddr, diallingNum, scaAddr_len);
1800         }
1801
1802         tpdu_len = sim_data->SmsData.MsgLength;
1803
1804         msg("SCA Number : %s tpdu_len is %d", scaAddr, tpdu_len);
1805
1806         pTPDU = malloc (sizeof(unsigned char) * tpdu_len);
1807         if (!pTPDU)
1808                 return;
1809
1810         msg("bfor memcopy position is %d", position);
1811         memcpy (pTPDU, & (sim_data->SmsData.szData[0]), tpdu_len);
1812         msg("after memcpy");
1813
1814         DecodeSmsDeliverTpdu (tpdu_len, pTPDU);
1815
1816         free (pTPDU);
1817 }
1818
1819 static void on_resp_save_msg (TapiHandle *handle, int result, void *data,
1820                 void *user_data)
1821 {
1822         int *index = data;
1823
1824         msg("");
1825         msgb("tel_write_sms_in_sim() response receive");
1826         msg(" - result = 0x%x", result);
1827         msg(" - index = %d", *index);
1828 }
1829
1830 static void on_resp_delete_msg (TapiHandle *handle, int result, void *data,
1831                 void *user_data)
1832 {
1833         int *index = data;
1834
1835         msg("");
1836         msgb("tel_delete_sms_in_sim() response receive");
1837         msg(" - result = 0x%x", result);
1838         msg(" - index = %d", *index);
1839 }
1840
1841 static void on_resp_DeliverReport_msg (TapiHandle *handle, int result,
1842                 void *data, void *user_data)
1843 {
1844         int *index = data;
1845
1846         msg("");
1847         msgb("tel_send_sms_deliver_report() response receive");
1848         msg(" - result = 0x%x", result);
1849         msg(" - index = %d", *index);
1850 }
1851
1852 static void on_resp_set_sms_sca (TapiHandle *handle, int result, void *data,
1853                 void *user_data)
1854 {
1855         msg("");
1856         msgb("tel_set_sms_sca() response receive");
1857         msg(" - result = 0x%x", result);
1858 }
1859
1860 static void on_resp_set_sms_preferred_bearer (TapiHandle *handle, int result,
1861                 void *data, void *user_data)
1862 {
1863         msg("");
1864         msgb("tel_set_sms_preferred_bearer() response receive");
1865         msg(" - result = 0x%x", result);
1866 }
1867
1868 static void on_resp_set_sms_cb_config (TapiHandle *handle, int result,
1869                 void *data, void *user_data)
1870 {
1871         msg("");
1872         msgb("tel_set_sms_cb_config() response receive");
1873         msg(" - result = 0x%x", result);
1874 }
1875
1876 static void on_resp_set_sms_params (TapiHandle *handle, int result, void *data,
1877                 void *user_data)
1878 {
1879         msg("");
1880         msgb("tel_set_sms_params() response receive");
1881         msg(" - result = 0x%x", result);
1882 }
1883
1884 static void on_resp_set_mem_status (TapiHandle *handle, int result, void *data,
1885                 void *user_data)
1886 {
1887         msg("");
1888         msgb("tel_set_sms_mem_status() response receive");
1889         msg(" - result = 0x%x", result);
1890 }
1891
1892 static void on_resp_get_sms_sca (TapiHandle *handle, int result, void *data,
1893                 void *user_data)
1894 {
1895         TelSmsAddressInfo_t *scaInfo = data;
1896         unsigned int i = 0;
1897
1898         msg("");
1899         msgb("tel_get_sms_sca() response receive");
1900         msg(" - result = 0x%x", result);
1901         msg(" - TON = %d", scaInfo->Ton);
1902         msg(" - NPI = %d", scaInfo->Npi);
1903         msg(" - DialNumLen = %d", scaInfo->DialNumLen);
1904         msg(" - SCA Num");
1905
1906         for (i = 0; i < scaInfo->DialNumLen; i++) {
1907                 msg("[%02x]", scaInfo->szDiallingNum[i]);
1908                 if (i % 10 == 9)
1909                         msg("\n");
1910         }
1911 }
1912
1913 static void on_resp_get_cb_config (TapiHandle *handle, int result, void *data,
1914                 void *user_data)
1915 {
1916         TelSmsCbConfig_t * CBConfig;
1917         int i = 0;
1918
1919         if (data == NULL ) {
1920                 msg("pData is Null")
1921                 return;
1922         }
1923
1924         CBConfig = (TelSmsCbConfig_t *) data;
1925
1926         msg("");
1927         msgb("tel_get_sms_cb_config() response receive");
1928         msg(" - result = 0x%x", result);
1929
1930         msg("=========CB Configuration=========");
1931
1932         /*** CB Enable/Diable ***/
1933         if (CBConfig->CBEnabled == TRUE)
1934                 msg("Cell Broadcast Msg Enabled...")
1935         else
1936                 msg("Cell Broadcast Msg Disabled...")
1937
1938         /*** Selected ID ***/
1939         if (CBConfig->Net3gppType == 0x01)
1940                 msg("Network type is 3gpp ")
1941         else if (CBConfig->Net3gppType == 0x02)
1942                 msg("Network type is CDMA");
1943
1944         /*** CBMI  Count ***/
1945         msg("CBMI Range Count: %d \n", CBConfig->MsgIdRangeCount);
1946
1947         /*** CBMI  List ***/
1948         if (CBConfig->MsgIdRangeCount != 0) {
1949                 msg("----- CBMI List -----");
1950                 for (i = 0; i < CBConfig->MsgIdRangeCount; i++) {
1951                         msg("From No.%d - [0x%04x]", i,
1952                                         CBConfig->MsgIDs[i].Net3gpp.FromMsgId);
1953                         msg("To No.%d - [0x%04x]", i, CBConfig->MsgIDs[i].Net3gpp.ToMsgId);
1954                 }
1955         }
1956         msg("==================================");
1957 }
1958
1959 static void on_resp_get_sms_parameters (TapiHandle *handle, int result,
1960                 void *data, void *user_data)
1961 {
1962         TelSmsParams_t *smsp_param;
1963
1964         if (data == NULL ) {
1965                 msg("data is Null")
1966                 return;
1967         }
1968         smsp_param = (TelSmsParams_t *) data;
1969
1970         msg("");
1971         msgb("tel_get_sms_parameters() response receive");
1972         msg(" - result = 0x%x", result);
1973
1974         msg("record index is 0x%x", smsp_param->RecordIndex);
1975         msg("record len  is 0x%x", smsp_param->RecordLen);
1976         msg("alpha_id len  is 0x%x ", (int )smsp_param->AlphaIdLen);
1977         msg("alpha_id is %s ", smsp_param->szAlphaId);
1978         msg("param indicator is  0x%x", smsp_param->ParamIndicator);
1979         msg("dest dialling num is %s", smsp_param->TpDestAddr.szDiallingNum);
1980         msg("svcaddr dialling num is %s", smsp_param->TpSvcCntrAddr.szDiallingNum);
1981         msg("pid 0x%x", smsp_param->TpProtocolId);
1982         msg("dcs is 0x%x", smsp_param->TpDataCodingScheme);
1983         msg("validity is 0x%x", smsp_param->TpValidityPeriod);
1984 }
1985
1986 static void on_resp_get_pref_bearer (TapiHandle *handle, int result, void *data,
1987                 void *user_data)
1988 {
1989         msg("");
1990         msgb("tel_get_sms_preferred_bearer() response receive");
1991         msg(" - result = 0x%x", result);
1992 }
1993
1994 static void on_resp_get_paramcnt (TapiHandle *handle, int result, void *data,
1995                 void *user_data)
1996 {
1997         int * RecordCount;
1998
1999         if (data == NULL ) {
2000                 msg("data is Null")
2001                 return;
2002         }
2003
2004         RecordCount = (int *) data;
2005
2006         msg("");
2007         msgb("tel_get_sms_parameter_count() response receive");
2008         msg(" - result = 0x%x", result);
2009         msg(" - In param_count_noti the record count is %d", *RecordCount);
2010 }
2011
2012 static void on_resp_get_sms_count (TapiHandle *handle, int result, void *data,
2013                 void *user_data)
2014 {
2015         static TelSmsStoredMsgCountInfo_t *countInfo;
2016         int loop_counter = 0;
2017         TapiResult_t returnStatus = TAPI_API_SUCCESS;
2018
2019         if (data == NULL ) {
2020                 msg("data is Null")
2021                 return;
2022         }
2023
2024         countInfo = (TelSmsStoredMsgCountInfo_t*) data;
2025
2026         msg("");
2027         msgb("tel_get_sms_count() response receive");
2028         msg(" - result = 0x%x", result);
2029
2030         if (countInfo->UsedCount != 0x00)       //if used count is not zero
2031                         {
2032                 msg("Index LIST..........");
2033                 for (loop_counter = 0; loop_counter < countInfo->UsedCount;
2034                                 loop_counter++) {
2035                         msg("[%02x]", countInfo->IndexList[loop_counter]);
2036                         returnStatus = tel_read_sms_in_sim (handle,
2037                                         countInfo->IndexList[loop_counter], on_resp_read_msg,
2038                                         NULL );
2039                         msg("After read msg: returnstatus %d", returnStatus);
2040                 }
2041                 msg("In MsgCountNotification total cnt is %d, usedcnt is %dapi_err %d",
2042                                 countInfo->TotalCount, countInfo->UsedCount, returnStatus);
2043         }
2044
2045         msg("In MsgCountNotification total cnt is %d, usedcnt is %d",
2046                         countInfo->TotalCount, countInfo->UsedCount);
2047
2048 }       //Madhavi
2049
2050 static int SendMessage (MManager *mm, struct menu_data *menu)
2051 {
2052         int ret;
2053         int msg_len = 0;
2054         char buf[SMS_ADDRESS_LEN_MAX];
2055         char message[512];
2056         char diallingNum[SMS_ADDRESS_LEN_MAX];
2057         int diallingNum_len = 0;
2058
2059         memset (buf, 0, sizeof (buf));
2060         memset (diallingNum, 0, sizeof (diallingNum));
2061         diallingNum_len = 0;
2062
2063         msg("Enter destination Number: ");
2064
2065         ret = read (0, buf, sizeof (buf));
2066         if (ret < 0) {
2067                 if (errno == EINTR)
2068                         perror ("read(1)");
2069                 return -1;
2070         }
2071         else if (ret == 0)
2072                 return ret;
2073
2074         buf[SMS_ADDRESS_LEN_MAX - 1] = '\0';
2075         diallingNum_len = strlen (diallingNum);
2076         memcpy (&diallingNum[diallingNum_len], buf, strlen (buf));
2077
2078         diallingNum_len = strlen (diallingNum); //recalculate
2079         msg("dialling num %s and dialling num len is %d", diallingNum,
2080                         diallingNum_len);
2081         diallingNum[diallingNum_len] = 0;
2082         diallingNum_len = diallingNum_len - 1;
2083
2084         msg("Enter Message: ");
2085         memset (message, 0, sizeof (message));
2086
2087         ret = read (0, message, sizeof (message) - 1);
2088
2089         if (ret <= 0) {
2090                 msg(" NULL msg can NOT be sent ");
2091                 return -1;
2092         }
2093         message[sizeof (message) - 1] = '\0';
2094
2095         msg_len = strlen (message);
2096         message[--msg_len] = 0;
2097
2098         msg("==========================");
2099         msg("To :%s", diallingNum);
2100         msg("Message: %sMsg Length:%d", message, msg_len);
2101         msg("Dialling number Length : %d", diallingNum_len);
2102         msg("==========================\n");
2103
2104         EncodeSmsSubmitTpdu (mm, diallingNum, diallingNum_len, message, msg_len);
2105         return 1;
2106
2107 }
2108
2109 static int SendMessageCDMA ()
2110 {
2111         int ret;
2112         int msg_len = 0;
2113         char buf[512] = { 0, };
2114         char message[512] = { 0, };
2115         char diallingNum[SMS_ADDRESS_LEN_MAX + 1] = { 0, };
2116         int diallingNum_len = 0;
2117
2118         printf ("\n");
2119         printf ("Enter destination Number:\n>> ");
2120         fflush (stdout);
2121
2122         ret = read (0, buf, sizeof (buf));
2123         if (ret < 0) {
2124                 if (errno == EINTR)
2125                         perror ("read(1)");
2126                 return -1;
2127         }
2128         else if (ret == 0)
2129                 return ret;
2130
2131         buf[SMS_ADDRESS_LEN_MAX - 1] = '\0';
2132         memcpy (diallingNum, buf, sizeof (diallingNum));
2133         diallingNum_len = strlen (diallingNum);
2134
2135         printf ("dialling num [%s], dialling num len [%d]\n", diallingNum,
2136                         diallingNum_len);
2137         printf ("Enter Message\n>> ");
2138         fflush (stdout);
2139
2140         ret = read (0, message, sizeof (message) - 1);
2141         if (ret <= 0) {
2142                 printf (" NULL msg can NOT be sent \n");
2143                 return -1;
2144         }
2145         message[sizeof (message) - 1] = '\0';
2146
2147         msg_len = strlen (message);
2148
2149         printf ("===========================\n");
2150         printf ("To: [%s] (len: %d)\n", diallingNum, diallingNum_len);
2151         printf ("Message: [%s]\nMsg Length: [%d]\n", message, msg_len);
2152         printf ("===========================\n\n");
2153
2154         EncodeCdmaSmsSubmitTpdu (diallingNum, diallingNum_len, message, msg_len);
2155         //EncodeSmsSubmitTpdu(diallingNum, diallingNum_len,message, msg_len) ;
2156
2157         return 1;
2158 }
2159
2160 static int ReadMessage (MManager *mm, struct menu_data *menu)
2161 {
2162         TapiHandle *handle = menu_manager_ref_user_data (mm);
2163         int selectedNo;
2164         int ret;
2165         char buf[100];
2166         int returnStatus = 0;
2167
2168         memset (buf, 0, sizeof (buf));
2169
2170         msg("*************************************");
2171         msg("1. SIM Message");
2172
2173         msg("Select Number:");
2174
2175         ret = read (0, buf, sizeof (buf));
2176
2177         if (ret < 0) {
2178                 if (errno == EINTR)
2179                         perror ("read(1)");
2180                 return -1;
2181         }
2182         else if (ret == 0)
2183                 return ret;
2184
2185         selectedNo = atoi (buf);
2186         msg("Selected Num in read message(value is 1) is %d ", selectedNo);
2187         switch (selectedNo) {
2188                 case 1:
2189
2190                         msg("***Reading the message in SIM***")
2191                         ;
2192                         returnStatus = tel_get_sms_count (handle, on_resp_get_sms_count,
2193                                         NULL );
2194                         msg("tel_get_sms_count():  0x%x", returnStatus)
2195                         ;
2196
2197                         break;
2198                 default:
2199                         msg("Not supported Menu(%d) !!!", selectedNo)
2200                         ;
2201                         break;
2202         }
2203
2204         return 1;
2205 }
2206
2207 static int DeleteMessage (MManager *mm, struct menu_data *menu)
2208 {
2209         TapiHandle *handle = menu_manager_ref_user_data (mm);
2210
2211         int ret;
2212         int index;
2213         char buf[100];
2214
2215         TapiResult_t returnStatus;
2216
2217         memset (buf, 0, sizeof (buf));
2218
2219         msg("Enter delete index >>");
2220
2221         ret = read (0, buf, sizeof (buf));
2222         if (ret < 0) {
2223                 if (errno == EINTR)
2224                         perror ("read(1)");
2225                 return -1;
2226         }
2227         else if (ret == 0)
2228                 return ret;
2229
2230         index = atoi (buf);
2231         msg("index value :%d", index);
2232
2233         msg("***Deleting the message(Api:DeleteMsg,GetMsgCount)***");
2234
2235         returnStatus = tel_delete_sms_in_sim (handle, index, on_resp_delete_msg,
2236                         NULL );
2237         msg("returnstatus  tel_delete_sms_in_sim()  is for delete%d ", returnStatus);
2238         returnStatus = tel_get_sms_count (handle, on_resp_get_sms_count, NULL );
2239         msg("returnStatus for tel_get_sms_count()  %d", returnStatus);
2240
2241         return 1;
2242
2243 }
2244
2245 static int Getting (MManager *mm, struct menu_data *menu)
2246 {
2247         TapiHandle *handle = menu_manager_ref_user_data (mm);
2248         int selectedNo;
2249         int returnStatus = 0;
2250         gboolean bReadyStatus = FALSE;
2251
2252         selectedNo = atoi (menu->key);
2253
2254         switch (selectedNo) {
2255                 case 1:
2256                         msg("***Getting the SCA(Api: GetSCA)****")
2257                         ;
2258                         returnStatus = tel_get_sms_sca (handle, 0, on_resp_get_sms_sca,
2259                                         NULL );
2260                         msg("returnstatus for tel_get_sms_sca(): 0x %x", returnStatus)
2261                         ;
2262
2263                         break;
2264
2265                 case 2:
2266                         msg("***Getting the CB Configuration(Api: GetCBConfig)***")
2267                         ;
2268                         returnStatus = tel_get_sms_cb_config (handle, on_resp_get_cb_config,
2269                                         NULL );
2270                         msg("ReturnStatus[%d] ", returnStatus)
2271                         ;
2272
2273                         break;
2274
2275                 case 3:
2276                         msg("****Getting the parameter(Api:GetParameter)****")
2277                         ;
2278                         returnStatus = tel_get_sms_parameters (handle, 0,
2279                                         on_resp_get_sms_parameters, NULL );
2280                         msg("ReturnStatus[%d]]", returnStatus)
2281                         ;
2282
2283                         break;
2284
2285                 case 4:
2286                         msg("***Getting preferrredBearer(Api:GetPreferredBearer)***")
2287                         ;
2288                         returnStatus = tel_get_sms_preferred_bearer (handle,
2289                                         on_resp_get_pref_bearer, NULL );
2290                         msg("ReturnStatus[%d]", returnStatus)
2291                         ;
2292
2293                         break;
2294
2295                 case 5:
2296                         msg("***Getting the parameterCount(Api:GetParameterCount)***")
2297                         ;
2298                         returnStatus = tel_get_sms_parameter_count (handle,
2299                                         on_resp_get_paramcnt, NULL );
2300                         msg("ReturnStatus[%d]", returnStatus)
2301                         ;
2302                         break;
2303
2304                 case 6:
2305                         msg("***Getting the SmsCount(Api:GetSmsCount)***")
2306                         ;
2307                         returnStatus = tel_get_sms_count (handle, on_resp_get_sms_count,
2308                                         NULL );
2309                         msg("ReturnStatus[%d]", returnStatus)
2310                         ;
2311
2312                         break;
2313
2314                 case 7:
2315                         msg(
2316                                         "***Getting the Sms Ready status(Api:Check_sms_device_status)***")
2317                         ;
2318                         returnStatus = tel_check_sms_device_status (handle, &bReadyStatus);
2319                         msg("ReturnStatus[%d]", returnStatus)
2320                         ;
2321                         msg("Ready status = %s", bReadyStatus ? "TRUE" : "FALSE")
2322                         ;
2323
2324                         break;
2325
2326                 default:
2327                         return -1;
2328
2329         }
2330
2331         return 1;
2332 }
2333
2334 static int _get_int()
2335 {
2336         char buf[255];
2337         int ret;
2338
2339         memset (buf, 0, 255);
2340         ret = read (0, buf, 254);
2341         if (ret <= 0)
2342                 return 0;
2343
2344         return atoi(buf);
2345 }
2346
2347 static int Setting (MManager *mm, struct menu_data *menu)
2348 {
2349         TapiHandle *handle = menu_manager_ref_user_data (mm);
2350
2351         int settingMenu;
2352         int ret;
2353         int i;
2354
2355         char MemoryStatus[255] = { 0, }; //2006/8/8
2356         char bearerType[255] = { 0, };  //2006/8/8
2357
2358         TelSmsCbConfig_t *pCBConfig;
2359
2360         TelSmsParams_t smsParameters = { 0, };
2361         TapiResult_t returnStatus;
2362
2363         settingMenu = atoi (menu->key);
2364
2365         switch (settingMenu) {
2366                 case 1:  //Set Service Center Number
2367                 {
2368                         msg("*** Setting SCA (API: tel_set_sms_sca()) ****");
2369                         TelSmsAddressInfo_t sca = {0, };
2370                         unsigned char sca_num[TAPI_SIM_SMSP_ADDRESS_LEN + 1];
2371                         unsigned int sca_length = 0;
2372                         unsigned int additional_len = 0;
2373                         unsigned index, j;
2374
2375                         RETRY:
2376                             msg("Enter the SCA NUMBER:");
2377                             ret = scanf("%s", sca_num);
2378                             if (ret > TAPI_SIM_SMSP_ADDRESS_LEN) {
2379                                 msg("Entered SCA is INVALID - SCA length cannot be greater than %d", TAPI_SIM_SMSP_ADDRESS_LEN);
2380                                 goto RETRY;
2381                             }
2382                             sca.Npi = TAPI_SIM_NPI_ISDN_TEL;
2383                             sca.Ton = TAPI_SIM_TON_UNKNOWN;
2384                             if (sca_num[0] == '+') {
2385                                 sca.Ton = TAPI_SIM_TON_INTERNATIONAL;
2386                                 additional_len = 1;
2387                             }
2388                             sca_length = strlen((char *)sca_num) - additional_len;
2389                             if (sca_length % 2 == 0) {
2390                                 for (index = additional_len, j = 0; index < sca_length; index += 2, j++)
2391                                     sca.szDiallingNum[j] = ((sca_num[index+1]-'0') << 4) | (sca_num[index]-'0');
2392                             } else {
2393                                 for (index = additional_len, j = 0; index < sca_length; index += 2, j++) {
2394                                     if (index == (sca_length - 1))
2395                                         sca.szDiallingNum[j] = ((0xF0) | (sca_num[index]-'0'));
2396                                     else
2397                                         sca.szDiallingNum[j] = ((sca_num[index+1]-'0') << 4) | (sca_num[index]-'0');
2398                                 }
2399                             }
2400                             sca.szDiallingNum[(sca_length+1)/2] = '\0';
2401                             sca.DialNumLen = strlen((char *)sca.szDiallingNum);
2402                             msg("%d", sca.DialNumLen);
2403                             returnStatus = tel_set_sms_sca (handle, &sca, 0, on_resp_set_sms_sca, NULL);
2404                             msg("Return status: [%d]", returnStatus);
2405                             break;
2406                 }
2407
2408                 case 2: {
2409                         msg("****Setting the BearerType(Api:SetPreferredBearer)****");
2410
2411                         msg("Enter Bearer Type(1:PD, 2:CS, 3:PDP 4:CSP):");
2412
2413                         memset (bearerType, 0, sizeof (bearerType));
2414
2415                         ret = read (0, bearerType, sizeof (bearerType));
2416                         if (ret <= 0) {
2417                                 msg(" NULL msg can NOT be sent ");
2418                                 return -1;
2419                         }
2420                         msg("Set Preferred Bearer : bearerType =%d ", atoi (bearerType));
2421
2422                         returnStatus = tel_set_sms_preferred_bearer (handle,
2423                                         atoi (bearerType), on_resp_set_sms_preferred_bearer, NULL );
2424                         msg("returnStatus  after prefbearer set  is %d", returnStatus);
2425
2426                         break;
2427                 }
2428
2429                 case 3: //Set Deliver Report
2430                 {
2431                         msg("****Setting  Deliver Report(Api:SetDeliverReport)****");
2432                         //EncodeSmsDeliverReportTpdu();
2433                         break;
2434                 }
2435
2436                 case 4: //Set CB Enable/Disable
2437                 {
2438                         msg("****Setting the CB configuration(Api:SetCbConfig)****");
2439
2440                         pCBConfig = calloc (1, sizeof(TelSmsCbConfig_t));
2441                         if (!pCBConfig)
2442                                 return -1;
2443
2444                         msg("Enter CB ON/OFF (1: Enable, 0:Disable): ");
2445                         pCBConfig->CBEnabled = _get_int();
2446
2447                         msg("Enter Max ID Count: ");
2448                         pCBConfig->MsgIdMaxCount = _get_int();
2449
2450                         msg("Enter MsgIdRangeCount ( < 10 ): ");
2451                         pCBConfig->MsgIdRangeCount = _get_int();
2452
2453                         if (pCBConfig->MsgIdRangeCount <= 0
2454                                         || pCBConfig->MsgIdRangeCount >= TAPI_NETTEXT_GSM_SMS_CBMI_LIST_SIZE_MAX) {
2455                                 msg("Bad Range value");
2456                                 free (pCBConfig);
2457                                 return -1;
2458                         }
2459
2460                         for (i = 0; i < pCBConfig->MsgIdRangeCount; i++) {
2461                                 msg("Enter %d FromMsgId : ", i + 1);
2462                                 pCBConfig->MsgIDs[i].Net3gpp.FromMsgId = _get_int();
2463
2464                                 msg("Enter %d ToMsgId : ", i + 1);
2465                                 pCBConfig->MsgIDs[i].Net3gpp.ToMsgId = _get_int();
2466
2467                                 msg("Enter %d Selected : ", i + 1);
2468                                 pCBConfig->MsgIDs[i].Net3gpp.Selected = _get_int();
2469                         }
2470
2471                         pCBConfig->Net3gppType = 0x01;
2472
2473                         msg(
2474                                         "from sms test setting the cb configuration:CBEnabled:%d,Net3gppType:%d,msgIdRangeCount:%d,From: %d\t To: %d\t Selected: %d",
2475                                         pCBConfig->CBEnabled, pCBConfig->Net3gppType,
2476                                         pCBConfig->MsgIdRangeCount,
2477                                         pCBConfig->MsgIDs[0].Net3gpp.FromMsgId,
2478                                         pCBConfig->MsgIDs[0].Net3gpp.ToMsgId,
2479                                         pCBConfig->MsgIDs[0].Net3gpp.Selected);
2480
2481                         returnStatus = tel_set_sms_cb_config (handle, pCBConfig,
2482                                         on_resp_set_sms_cb_config, NULL );
2483                         msg("returnStatus after cbconfig set is is [%d]", returnStatus);
2484
2485                         free (pCBConfig);
2486
2487                         break;
2488                 }
2489                 case 5: {
2490                         char* name = "Lpg";
2491                         char* num = "0103001408";
2492                         char* sca = "8210911111";
2493
2494                         msg("****Setting Parameters(Api:SetParameters)****");
2495
2496                         smsParameters.RecordIndex = 0x00;
2497                         smsParameters.RecordLen = 31;
2498                         smsParameters.AlphaIdLen = 3;
2499                         memcpy (&smsParameters.szAlphaId, name, strlen (name));
2500
2501                         smsParameters.ParamIndicator = 0xe0;
2502                         smsParameters.TpDestAddr.DialNumLen = 10;
2503                         smsParameters.TpDestAddr.Ton = 1;
2504                         smsParameters.TpDestAddr.Npi = 1;
2505
2506                         smsParameters.TpSvcCntrAddr.DialNumLen = 10;
2507                         smsParameters.TpSvcCntrAddr.Ton = 1;
2508                         smsParameters.TpSvcCntrAddr.Npi = 1;
2509
2510                         memcpy (smsParameters.TpDestAddr.szDiallingNum, num, strlen (num));
2511                         memcpy (smsParameters.TpSvcCntrAddr.szDiallingNum, sca,
2512                                         strlen (sca));
2513                         smsParameters.TpProtocolId = 3;
2514                         smsParameters.TpDataCodingScheme = 2;
2515                         smsParameters.TpValidityPeriod = 1;
2516
2517                         returnStatus = tel_set_sms_parameters (handle, &smsParameters,
2518                                         on_resp_set_sms_params, NULL );
2519                         msg("returnstatus after sparam set  is %d", returnStatus);
2520
2521                         break;
2522                 }
2523
2524                 case 6: //Set Memory Full Notification
2525                 {
2526                         msg(
2527                                         "Enter Memory Status to be set(1:Memory Available, 2:Memory Full)");
2528                         memset (MemoryStatus, 0, sizeof (MemoryStatus));
2529                         ret = read (0, MemoryStatus, sizeof (MemoryStatus));
2530                         if (ret <= 0) {
2531                                 msg(" NULL msg can NOT be sent ");
2532                                 return -1;
2533                         }
2534                         msg("Memory Status type is %d ", atoi (MemoryStatus));
2535                         returnStatus = tel_set_sms_memory_status (handle,
2536                                         atoi (MemoryStatus), on_resp_set_mem_status, NULL ); //Set to full 0x02-Full, 0x01-available
2537                         msg("api err after memstatus set is is %d", returnStatus);
2538
2539                         break;
2540                 }
2541                 case 7: //Set Stored MsgStaus
2542                 {
2543 #if 0 //JYGU
2544                         memType=2;
2545                         index=2;
2546                         msgStauts =2;
2547
2548                         //TapiReadNetText(index, &CurMsgStauts, &DataPackage);
2549                         returnStatus = tel_read_sms_in_sim(index,&requestId);//To avoid  mismatch of prototypes
2550                         msg("returnStatus after read is is %d",returnStatus);
2551
2552                         msg("Before set status : index = %d, CurMsgStauts=%d",index,msgStauts);
2553
2554                         returnStatus = tel_set_sms_message_status(index, msgStauts,&requestId);
2555                         msg("returnStatus after msgstatus set is %d",returnStatus);
2556
2557                         //tel_nettext_read(index, &CurMsgStauts, &DataPackage);
2558                         returnStatus = tel_read_sms_in_sim(index,&requestId);//To avoid  mismatch of prototypes
2559                         msg("returnStatus after read is %d",returnStatus);
2560 #endif
2561                         msg("Not suppored in this Test App !!!");
2562                         break;
2563                 }
2564                 case 8: {
2565 // JYGU                         returnStatus =tel_set_sms_device_status();
2566                         msg("Not suppored in this Test App !!!");
2567                         break;
2568                 }
2569                 case 9: {
2570 #if 0 //JYGU
2571                         int status = 0;
2572                         returnStatus =tel_check_sms_device_status(&status);
2573                         if (status == 1)
2574                         {
2575                                 msg("Device Ready");
2576                         }
2577                         else
2578                         {
2579                                 msg("Device Not Ready");
2580                         }
2581                         msg("returnStatus after read is %d",returnStatus);
2582 #endif
2583                         msg("Not suppored in this Test App !!!");
2584                         break;
2585                 }
2586                 default:
2587                         return -1;
2588         }
2589         return 1;
2590 }
2591
2592 static struct menu_data menu_sms_getting[] = { { "1",
2593                 "Get Service Center Number", NULL, Getting, NULL }, { "2",
2594                 "Get CB Setting Information", NULL, Getting, NULL }, { "3",
2595                 "Get SMS Parameters", NULL, Getting, NULL }, { "4",
2596                 "Get SMS PreferredBearer Information (Not supported)", NULL, Getting,
2597                 NULL }, { "5", "Get SMS Parameter Count", NULL, Getting, NULL }, { "6",
2598                 "Get Message Count", NULL, Getting, NULL }, { "7",
2599                 "Get SMS ready status", NULL, Getting, NULL }, { NULL, NULL , }, };
2600
2601 static struct menu_data menu_sms_setting[] =
2602                 { { "1", "Set Service Center Number", NULL, Setting, NULL }, { "2",
2603                                 "Set PreferredBearer Type", NULL, Setting, NULL }, { "3",
2604                                 "Set Deliver Report", NULL, Setting, NULL }, { "4",
2605                                 "Set CB Enable/Disable", NULL, Setting, NULL }, { "5",
2606                                 "Set SMS Parameters", NULL, Setting, NULL }, { "6",
2607                                 "Set Memory Status", NULL, Setting, NULL }, { "7",
2608                                 "Set Stored MsgStaus", NULL, Setting, NULL }, { "8",
2609                                 "Set Device Ready", NULL, Setting, NULL }, { "9",
2610                                 "Check Device Status", NULL, Setting, NULL }, { NULL, NULL , }, };
2611
2612 static struct menu_data menu_sms_wcdma[] = { { "1", "Send Message", NULL,
2613                 SendMessage, NULL }, { "2", "Read Message", NULL, ReadMessage, NULL }, {
2614                 "3", "Delete Message", NULL, DeleteMessage, NULL }, { "4",
2615                 "Delete All Message", NULL, NULL, NULL },       //DeleteAllMessage
2616                 { "5", "Setting", menu_sms_setting, NULL, NULL }, { "6",
2617                                 "Getting SMS Information", menu_sms_getting, NULL, NULL }, {
2618                                 NULL, NULL , }, };
2619
2620 static struct menu_data menu_sms_cdma[] = { { "1", "Send Message", NULL,
2621                 SendMessageCDMA, NULL }, { NULL, NULL , }, };
2622
2623 struct menu_data menu_sms[] = { { "1", "WCDMA", menu_sms_wcdma, NULL, NULL }, {
2624                 "2", "CDMA", menu_sms_cdma, NULL, NULL }, { NULL, NULL , }, };
2625
2626 void register_sms_event (TapiHandle *handle)
2627 {
2628         int ret;
2629
2630         /* SMS */
2631         ret = tel_register_noti_event (handle, TAPI_NOTI_SMS_INCOM_MSG,
2632                         on_noti_sms_incom_msg, NULL );
2633         if (ret != TAPI_API_SUCCESS) {
2634                 msg("event register failed(%d)", ret);
2635         }
2636
2637         ret = tel_register_noti_event (handle, TAPI_NOTI_SMS_CB_INCOM_MSG,
2638                         on_noti_sms_cb_incom_msg, NULL );
2639         if (ret != TAPI_API_SUCCESS) {
2640                 msg("event register failed(%d)", ret);
2641         }
2642
2643         ret = tel_register_noti_event (handle, TAPI_NOTI_SMS_ETWS_INCOM_MSG,
2644                         on_noti_sms_etws_incom_msg, NULL );
2645         if (ret != TAPI_API_SUCCESS) {
2646                 msg("event register failed(%d)", ret);
2647         }
2648
2649 //        ret = tel_register_noti_event(handle, TAPI_NOTI_SMS_INCOM_EX_MSG, on_noti_sms_incom_ex_msg, NULL);
2650 //        ret = tel_register_noti_event(handle, TAPI_NOTI_SMS_CB_INCOM_EX_MSG, on_noti_sms_cb_incom_ex_msg, NULL);
2651
2652         ret = tel_register_noti_event (handle, TAPI_NOTI_SMS_MEMORY_STATUS,
2653                         on_noti_sms_memory_status, NULL );
2654         if (ret != TAPI_API_SUCCESS) {
2655                 msg("event register failed(%d)", ret);
2656         }
2657
2658         ret = tel_register_noti_event (handle, TAPI_NOTI_SMS_DEVICE_READY,
2659                         on_noti_sms_ready_status, NULL );
2660         if (ret != TAPI_API_SUCCESS) {
2661                 msg("event register failed(%d)", ret);
2662         }
2663 }