plugin/sms_plugin/SmsPluginCbMsgHandler.cpp

   1 /*
   2 * Copyright 2012  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 *    http://www.tizenopensource.org/license
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <time.h>
  18
  19 #include "MsgDebug.h"
  20 #include "MsgCppTypes.h"
  21 #include "MsgException.h"
  22 #include "MsgGconfWrapper.h"
  23 #include "MsgUtilFile.h"
  24 #include "SmsPluginTextConvert.h"
  25 #include "SmsPluginUDCodec.h"
  26 #include "SmsPluginStorage.h"
  27 #include "SmsPluginEventHandler.h"
  28 #include "SmsPluginCbMsgHandler.h"
  29
  30
  31 /*==================================================================================================
  32                                      IMPLEMENTATION OF SmsPluginCbMsgHandler - Member Functions
  33 ==================================================================================================*/
  34 SmsPluginCbMsgHandler* SmsPluginCbMsgHandler::pInstance = NULL;
  35
  36
  37 SmsPluginCbMsgHandler::SmsPluginCbMsgHandler()
  38 {
  39         pageList.clear();
  40 }
  41
  42
  43 SmsPluginCbMsgHandler::~SmsPluginCbMsgHandler()
  44 {
  45
  46 }
  47
  48
  49 SmsPluginCbMsgHandler* SmsPluginCbMsgHandler::instance()
  50 {
  51         if (!pInstance)
  52                 pInstance = new SmsPluginCbMsgHandler();
  53
  54         return pInstance;
  55 }
  56
  57
  58 void SmsPluginCbMsgHandler::handleCbMsg(TelSmsCbMsg_t *pCbMsg)
  59 {
  60         MSG_BEGIN();
  61
  62         SMS_CB_NETWORK_TYPE_T type = pCbMsg->CbMsgType;
  63
  64         SMS_CBMSG_PAGE_S CbMsgPage = {0};
  65
  66         switch (type)
  67         {
  68                 case SMS_CB_NETWORK_TYPE_2G_GSM :
  69                         Decode2gCbMsg(pCbMsg, &CbMsgPage);
  70                 break;
  71
  72                 case SMS_CB_NETWORK_TYPE_3G_UMTS :
  73                         Decode3gCbMsg(pCbMsg, &CbMsgPage);
  74                 break;
  75         }
  76
  77         // Check CB Msg Options
  78         bool bJavaMsg = false;
  79
  80         if (!checkCbOpt(CbMsgPage, &bJavaMsg))
  81         {
  82                 MSG_DEBUG("The CB Msg is not supported by option.");
  83                 return;
  84         }
  85
  86         if (bJavaMsg == true)
  87         {
  88                 MSG_DEBUG("JAVA CB Msg.");
  89                 CbMsgPage.cbMsgType = SMS_CBMSG_TYPE_JAVACBS;
  90         }
  91
  92         // Check CB Pages
  93         unsigned char pageCnt = checkCbPage(CbMsgPage);
  94
  95         if (pageCnt == CbMsgPage.pageHeader.totalPages)
  96         {
  97                 MSG_DEBUG("RECEIVED LAST MSG : %d", pageCnt);
  98
  99                 SMS_CBMSG_S cbMsg = {};
 100                 MSG_MESSAGE_INFO_S msgInfo = {};
 101
 102                 // Make CB Msg Structure
 103                 MakeCbMsg(CbMsgPage, &cbMsg);
 104
 105                 // Convert to MSG_MESSAGE_INFO_S
 106                 convertCbMsgToMsginfo(cbMsg, &msgInfo);
 107
 108                 // Add CB Msg into DB
 109                 msg_error_t err = MSG_SUCCESS;
 110
 111                 err = SmsPluginStorage::instance()->addMessage(&msgInfo);
 112
 113                 if (err == MSG_SUCCESS)
 114                 {
 115                         MSG_CB_MSG_S cbOutMsg = {0, };
 116
 117                         cbOutMsg.type = MSG_CB_SMS;
 118                         cbOutMsg.receivedTime = cbMsg.recvTime;
 119                         cbOutMsg.serialNum = encodeCbSerialNum (CbMsgPage.pageHeader.serialNum);
 120                         cbOutMsg.messageId = cbMsg.msgId;
 121                         cbOutMsg.dcs = CbMsgPage.pageHeader.dcs.rawData;
 122                         memset (cbOutMsg.cbText, 0x00, sizeof(cbOutMsg.cbText));
 123
 124                         SMS_LANG_INFO_S langInfo = {0};
 125
 126                         langInfo.bSingleShift = false;
 127                         langInfo.bLockingShift = false;
 128
 129                         if (cbMsg.codingScheme == SMS_CHARSET_7BIT)
 130                                 cbOutMsg.cbTextLen = SmsPluginTextConvert::instance()->convertGSM7bitToUTF8((unsigned char*)cbOutMsg.cbText, sizeof(cbOutMsg.cbText), (unsigned char*)cbMsg.msgData, cbMsg.msgLength, &langInfo);
 131                         else if (cbMsg.codingScheme == SMS_CHARSET_UCS2)
 132                                 cbOutMsg.cbTextLen = SmsPluginTextConvert::instance()->convertUCS2ToUTF8((unsigned char*)cbOutMsg.cbText, sizeof(cbOutMsg.cbText), (unsigned char*)cbMsg.msgData, cbMsg.msgLength);
 133
 134
 135                         err = SmsPluginEventHandler::instance()->callbackCBMsgIncoming(&cbOutMsg);
 136                         if (err != MSG_SUCCESS)
 137                         {
 138                                 MSG_DEBUG("callbackMsgIncoming() Error !! [%d]", err);
 139                         }
 140                 }
 141                 else
 142                 {
 143                         MSG_DEBUG("addMessage() Error !! [%d]", err);
 144                 }
 145
 146                 // Remove From List
 147                 removeFromPageList(CbMsgPage);
 148         }
 149         MSG_END();
 150 }
 151
 152
 153 void SmsPluginCbMsgHandler::handleEtwsMsg(TelSmsEtwsMsg_t *pEtwsMsg)
 154 {
 155         MSG_BEGIN();
 156         msg_error_t err = MSG_SUCCESS;
 157         SMS_ETWS_NETWORK_TYPE_T type = pEtwsMsg->EtwsMsgType;
 158         //MSG_MESSAGE_INFO_S msgInfo = {};
 159         SMS_ETWS_PRIMARY_S              etwsPn = {0, };
 160         MSG_CB_MSG_S                    cbOutMsg = {0, };
 161
 162         if(type != TAPI_NETTEXT_ETWS_PRIMARY)
 163         {
 164                 MSG_DEBUG("The Etws Msg is not supported");
 165                 return;
 166         }
 167         DecodeEtwsMsg(pEtwsMsg, &etwsPn);
 168         //convertEtwsMsgToMsginfo(CbMsgPage, &msgInfo);
 169
 170         cbOutMsg.type = MSG_ETWS_SMS;
 171         cbOutMsg.receivedTime = etwsPn.recvTime;
 172         cbOutMsg.serialNum = encodeCbSerialNum (etwsPn.serialNum);
 173         cbOutMsg.messageId = etwsPn.msgId;
 174         cbOutMsg.etwsWarningType = etwsPn.warningType;
 175         memcpy (cbOutMsg.etwsWarningSecurityInfo, etwsPn.warningSecurityInfo, sizeof(cbOutMsg.etwsWarningSecurityInfo));
 176
 177         err = SmsPluginEventHandler::instance()->callbackCBMsgIncoming(&cbOutMsg);
 178         if (err != MSG_SUCCESS)
 179         {
 180                 MSG_DEBUG("callbackMsgIncoming() Error !! [%d]", err);
 181         }
 182
 183         MSG_END();
 184 }
 185
 186
 187 void SmsPluginCbMsgHandler::Decode2gCbMsg(TelSmsCbMsg_t *pCbMsg, SMS_CBMSG_PAGE_S *pCbPage)
 188 {
 189         if (pCbMsg->Length > MAX_CBMSG_PAGE_SIZE)
 190                 THROW(MsgException::SMS_PLG_ERROR, "CB Msg Size is over MAX [%d]", pCbMsg->Length);
 191
 192         unsigned char cbData[pCbMsg->Length+1];
 193
 194         memset(cbData, 0x00, sizeof(cbData));
 195         memcpy(cbData, pCbMsg->szMsgData, pCbMsg->Length);
 196         cbData[pCbMsg->Length] = '\0';
 197
 198         pCbPage->cbMsgType = SMS_CBMSG_TYPE_CBS;
 199
 200         // Serial Number
 201         pCbPage->pageHeader.serialNum.geoScope = (cbData[0] & 0xC0) >> 6;
 202
 203         pCbPage->pageHeader.serialNum.msgCode = (cbData[0] & 0x3F) << 4;
 204         pCbPage->pageHeader.serialNum.msgCode |= (cbData[1] & 0xF0) >> 4;
 205
 206         pCbPage->pageHeader.serialNum.updateNum = cbData[1] & 0x0F;
 207
 208 MSG_DEBUG("geoScope : [%d], msgCode : [%d], updateNum : [%d]", pCbPage->pageHeader.serialNum.geoScope, pCbPage->pageHeader.serialNum.msgCode, pCbPage->pageHeader.serialNum.updateNum);
 209
 210         pCbPage->pageHeader.msgId = (cbData[2] << 8) | cbData[3];
 211
 212 MSG_DEBUG("MSG ID : [%d]", pCbPage->pageHeader.msgId);
 213
 214         // DCS
 215         decodeCbMsgDCS(cbData[4], (unsigned char*)cbData[6], &(pCbPage->pageHeader.dcs));
 216
 217         // Page Parameter
 218         pCbPage->pageHeader.totalPages = cbData[5] & 0x0F;
 219         pCbPage->pageHeader.page = (cbData[5] & 0xF0) >> 4;
 220
 221         if (pCbPage->pageHeader.totalPages > MAX_CBMSG_PAGE_NUM)
 222                 THROW(MsgException::SMS_PLG_ERROR, "CB Page Count is over MAX[%d]", pCbPage->pageHeader.totalPages);
 223
 224 MSG_DEBUG("Total Page : [%d], Page : [%d]", pCbPage->pageHeader.totalPages, pCbPage->pageHeader.page);
 225
 226         // Convert Language Type
 227         convertLangType(pCbPage->pageHeader.dcs.langType, &(pCbPage->pageHeader.langType));
 228
 229 MSG_DEBUG("In Language Type : [%d], Out Language Type : [%d]", pCbPage->pageHeader.dcs.langType, pCbPage->pageHeader.langType);
 230
 231         // Get Receive Time
 232         pCbPage->pageHeader.recvTime = getRecvTime();
 233
 234         // Decode CB Data
 235         int dataLen = pCbMsg->Length - 6;
 236
 237         switch (pCbPage->pageHeader.dcs.codingScheme)
 238         {
 239                 case SMS_CHARSET_7BIT :
 240                 {
 241                         MSG_DEBUG("GSM 7 BIT");
 242
 243                         dataLen = (dataLen*8) / 7;
 244
 245                         SmsPluginUDCodec udCodec;
 246                         int unpackLen = udCodec.unpack7bitChar(&cbData[6], dataLen, 0, pCbPage->pageData);
 247
 248 MSG_DEBUG("dataLen : [%d]", dataLen);
 249 MSG_DEBUG("unpackLen : [%d]", unpackLen);
 250
 251                         pCbPage->pageLength = unpackLen;
 252                         pCbPage->pageData[unpackLen] = '\0';
 253
 254 //                      pCbPage->pageLength = strlen(pCbPage->pageData);
 255 //                      pCbPage->pageData[pCbPage->pageLength] = '\0';
 256                 }
 257                 break;
 258
 259                 case SMS_CHARSET_8BIT :
 260                 case SMS_CHARSET_UCS2 :
 261                 {
 262                         MSG_DEBUG("UCS2");
 263
 264                         memcpy(pCbPage->pageData, &cbData[6], dataLen);
 265
 266                         pCbPage->pageLength = strlen(pCbPage->pageData);
 267
 268                         pCbPage->pageData[pCbPage->pageLength] = '\0';
 269                 }
 270                 break;
 271         }
 272
 273 MSG_DEBUG("Page Length : [%d], Page Data : [%s]", pCbPage->pageLength, pCbPage->pageData);
 274 }
 275
 276
 277 void SmsPluginCbMsgHandler::DecodeEtwsMsg(TelSmsEtwsMsg_t *pEtwsMsg, SMS_ETWS_PRIMARY_S *pEtwsPn)
 278 {
 279         if ( !pEtwsMsg || !pEtwsPn )
 280                 return;
 281
 282         if (pEtwsMsg->Length > MAX_ETWS_SIZE)
 283                 THROW(MsgException::SMS_PLG_ERROR, "ETWS Msg Size is over MAX [%d]", pEtwsMsg->Length);
 284
 285         unsigned char EtwsData[pEtwsMsg->Length+1];
 286
 287         memset(EtwsData, 0x00, sizeof(EtwsData));
 288         memcpy(EtwsData, pEtwsMsg->szMsgData, pEtwsMsg->Length);
 289         EtwsData[pEtwsMsg->Length] = '\0';
 290
 291         // received time
 292         pEtwsPn->recvTime = getRecvTime();
 293
 294         // Serial Number
 295         pEtwsPn->serialNum.geoScope = (EtwsData[0] & 0xC0) >> 6;
 296         pEtwsPn->serialNum.msgCode = (EtwsData[0] & 0x3F) << 4;
 297         pEtwsPn->serialNum.msgCode |= (EtwsData[1] & 0xF0) >> 4;
 298         pEtwsPn->serialNum.updateNum = EtwsData[1] & 0x0F;
 299
 300         MSG_DEBUG("geoScope : [%d], msgCode : [%d], updateNum : [%d]", pEtwsPn->serialNum.geoScope, pEtwsPn->serialNum.msgCode, pEtwsPn->serialNum.updateNum);
 301
 302         // Message Identifier
 303         pEtwsPn->msgId = (EtwsData[2] << 8) | EtwsData[3];
 304         MSG_DEBUG("MSG ID : [%d]", pEtwsPn->msgId);
 305
 306         // warning type
 307         pEtwsPn->warningType = (EtwsData[4] << 8) | EtwsData[5];
 308         MSG_DEBUG("warningType : [0x%04x]", pEtwsPn->msgId);
 309
 310         // warning security information
 311         memcpy(pEtwsPn->warningSecurityInfo, &EtwsData[6], sizeof(pEtwsPn->warningSecurityInfo));       // 50bytes
 312         for (unsigned int i = 0; i < sizeof(pEtwsPn->warningSecurityInfo); i++)
 313         {
 314                 MSG_DEBUG("warning secu info [%02x]", pEtwsPn->warningSecurityInfo[i] );
 315         }
 316 }
 317
 318 void SmsPluginCbMsgHandler::Decode3gCbMsg(TelSmsCbMsg_t *pCbMsg, SMS_CBMSG_PAGE_S *pCbPage)
 319 {
 320         if (pCbMsg->Length > (MAX_CBMSG_PAGE_SIZE*MAX_CBMSG_PAGE_NUM))
 321                 THROW(MsgException::SMS_PLG_ERROR, "CB Msg Size is over MAX [%d]", pCbMsg->Length);
 322
 323         char cbData[(MAX_CBMSG_PAGE_SIZE*MAX_CBMSG_PAGE_NUM)+1];
 324
 325         memset(cbData, 0x00, sizeof(cbData));
 326         memcpy(cbData, pCbMsg->szMsgData, pCbMsg->Length);
 327         cbData[pCbMsg->Length] = '\0';
 328
 329         pCbPage->cbMsgType = (SMS_CBMSG_TYPE_T)cbData[0];
 330
 331         pCbPage->pageHeader.msgId = (cbData[1] << 8) | cbData[2];
 332
 333 MSG_DEBUG("MSG ID : [%d]", pCbPage->pageHeader.msgId);
 334
 335         // Serial Number
 336         pCbPage->pageHeader.serialNum.geoScope = (cbData[3] & 0xC0) >> 6;
 337
 338         pCbPage->pageHeader.serialNum.msgCode = (cbData[3] & 0x3F) << 4;
 339         pCbPage->pageHeader.serialNum.msgCode |= (cbData[4] & 0xF0) >> 4;
 340
 341         pCbPage->pageHeader.serialNum.updateNum = cbData[4] & 0x0F;
 342
 343 MSG_DEBUG("geoScope : [%d], msgCode : [%d], updateNum : [%d]", pCbPage->pageHeader.serialNum.geoScope, pCbPage->pageHeader.serialNum.msgCode, pCbPage->pageHeader.serialNum.updateNum);
 344
 345         // DCS
 346         decodeCbMsgDCS(cbData[5], (unsigned char*)cbData[6], &(pCbPage->pageHeader.dcs));
 347
 348         // Convert Language Type
 349         convertLangType(pCbPage->pageHeader.dcs.langType, &(pCbPage->pageHeader.langType));
 350
 351 MSG_DEBUG("In Language Type : [%d], Out Language Type : [%d]", pCbPage->pageHeader.dcs.langType, pCbPage->pageHeader.langType);
 352
 353         // Get Receive Time
 354         pCbPage->pageHeader.recvTime = getRecvTime();
 355
 356 #if 0
 357         // Decode CB Data
 358         int dataLen = pCbMsg->Length - 6;
 359
 360         switch (pCbPage->pageHeader.dcs.codingScheme)
 361         {
 362                 case SMS_CHARSET_7BIT :
 363                 {
 364                         dataLen = (dataLen*8) / 7;
 365
 366                         if (pCbPage->pageLength > MAX_CBMSG_PAGE_SIZE)
 367                                 THROW(MsgException::SMS_PLG_ERROR, "CB Msg Size is over MAX [%d]", pCbPage->pageLength);
 368
 369                         SmsPluginUDCodec udCodec;
 370                         int unpackLen = udCodec.unpack7bitChar(&cbData[6], dataLen, 0, pCbPage->pageData);
 371                         pCbPage->pageData[unpackLen] = '\0';
 372
 373                         pCbPage->pageLength = unpackLen;
 374                 }
 375                 break;
 376
 377                 case SMS_CHARSET_8BIT :
 378                 case SMS_CHARSET_UCS2 :
 379                 {
 380                         pCbPage->pageLength = dataLen;
 381
 382                         memcpy(pCbPage->pageData, &cbData[6], pCbPage->pageLength);
 383                         pCbPage->pageData[pCbPage->pageLength] = '\0';
 384                 }
 385                 break;
 386         }
 387
 388 MSG_DEBUG("Page Length : [%d], Page Data : [%s]", pCbPage->pageLength, pCbPage->pageData);
 389 #endif
 390 }
 391
 392 unsigned short SmsPluginCbMsgHandler::encodeCbSerialNum ( SMS_CBMSG_SERIAL_NUM_S snFields )
 393 {
 394         unsigned short serialNum = 0;
 395
 396         serialNum = ((snFields.geoScope & 0x03) << 14) | ((snFields.msgCode&0x03FF) << 4) | (snFields.updateNum&0x0F);
 397         MSG_DEBUG ("serialNum (%x), geo(%x), mc(%x), un(%x)\n", serialNum, snFields.geoScope, snFields.msgCode, snFields.updateNum);
 398
 399         return serialNum;
 400 }
 401
 402 bool SmsPluginCbMsgHandler::checkCbOpt(SMS_CBMSG_PAGE_S CbPage, bool *pJavaMsg)
 403 {
 404         bool bReceive = false;
 405         MsgSettingGetBool(CB_RECEIVE, &bReceive);
 406
 407         // Receive CB Msg = FALSE
 408         if (!bReceive)
 409         {
 410                 MSG_DEBUG("RECEIVE CB = FALSE");
 411                 return false;
 412         }
 413
 414         char keyName[128];
 415
 416         // check Language
 417         memset(keyName, 0x00, sizeof(keyName));
 418         sprintf(keyName, "%s/%d", CB_LANGUAGE, MSG_CBLANG_TYPE_ALL);
 419
 420         bool bAllLang = false;
 421         MsgSettingGetBool(keyName, &bAllLang);
 422
 423         if (!bAllLang)
 424         {
 425                 MSG_DEBUG("ALL LANGUAGE = FALSE");
 426
 427                 memset(keyName, 0x00, sizeof(keyName));
 428                 sprintf(keyName, "%s/%d", CB_LANGUAGE, CbPage.pageHeader.langType);
 429
 430                 bool bLang = false;
 431
 432                 MsgSettingGetBool(keyName, &bLang);
 433
 434                 if (!bLang || CbPage.pageHeader.langType == MSG_CBLANG_TYPE_MAX)
 435                 {
 436                         MSG_DEBUG("LANGUAGE [%d] = FALSE", CbPage.pageHeader.langType);
 437                         return false;
 438                 }
 439         }
 440
 441         int MsgIdCnt = MsgSettingGetInt(CB_CHANNEL_COUNT);
 442
 443         bool bActivate = false;
 444         int MsgId_from = 0, MsgId_to = 0;
 445
 446         for (int i = 0; i < MsgIdCnt; i++)
 447         {
 448                 memset(keyName, 0x00, sizeof(keyName));
 449                 sprintf(keyName, "%s/%d", CB_CHANNEL_ACTIVATE, i);
 450
 451                 MsgSettingGetBool(keyName, &bActivate);
 452
 453                 memset(keyName, 0x00, sizeof(keyName));
 454                 sprintf(keyName, "%s/%d", CB_CHANNEL_ID_FROM, i);
 455
 456                 MsgId_from = MsgSettingGetInt(keyName);
 457
 458                 memset(keyName, 0x00, sizeof(keyName));
 459                 sprintf(keyName, "%s/%d", CB_CHANNEL_ID_TO, i);
 460
 461                 MsgId_to = MsgSettingGetInt(keyName);
 462
 463                 if (bActivate == true && CbPage.pageHeader.msgId >= MsgId_from && CbPage.pageHeader.msgId <= MsgId_to)
 464                 {
 465                         MSG_DEBUG("FIND CHANNEL = [%d]", CbPage.pageHeader.msgId);
 466                         return true;
 467                 }
 468         }
 469
 470         return false;
 471 }
 472
 473
 474 unsigned char SmsPluginCbMsgHandler::checkCbPage(SMS_CBMSG_PAGE_S CbPage)
 475 {
 476         unsigned char currPageCnt = 0;
 477
 478         bool bFind = false;
 479
 480         if (CbPage.pageHeader.totalPages > 1)
 481         {
 482                 for (unsigned int i = 0; i < pageList.size(); i++)
 483                 {
 484                         if (pageList[i].geoScope == CbPage.pageHeader.serialNum.geoScope && pageList[i].msgCode == CbPage.pageHeader.serialNum.msgCode)
 485                         {
 486                                 MSG_DEBUG("geoScope [%d], msgCode [%d]", pageList[i].geoScope, pageList[i].msgCode);
 487
 488                                 if (pageList[i].msgId == CbPage.pageHeader.msgId)
 489                                 {
 490                                         int updateNum = CbPage.pageHeader.serialNum.updateNum - pageList[i].updateNum;
 491
 492                                         if (updateNum > 0) // New Message Content
 493                                         {
 494                                                 break;
 495                                         }
 496                                         else if (updateNum == 0) // Same Message Content
 497                                         {
 498                                                 if (pageList[i].data.count(CbPage.pageHeader.page) != 0)
 499                                                 {
 500                                                         MSG_DEBUG("The Page Number already exists [%d]", CbPage.pageHeader.page);
 501                                                         return 0;
 502                                                 }
 503
 504                                                 pair<unsigned char, string> newData(CbPage.pageHeader.page, CbPage.pageData);
 505                                                 pageList[i].data.insert(newData);
 506
 507                                                 MSG_DEBUG("PAGE DATA : %s", CbPage.pageData);
 508                                                 MSG_DEBUG("PAIR DATA [%d] : %s", newData.first, newData.second.c_str());
 509
 510                                                 pageList[i].pageCnt++;
 511                                                 pageList[i].totalSize += CbPage.pageLength;
 512
 513                                                 currPageCnt = pageList[i].pageCnt;
 514
 515                                                 bFind = true;
 516
 517                                                 break;
 518                                         }
 519                                         else // Old Message Content
 520                                         {
 521                                                 return 0;
 522                                         }
 523                                 }
 524                         }
 525                 }
 526         }
 527
 528         if (bFind == false || CbPage.pageHeader.totalPages == 1)
 529         {
 530                 addToPageLiat(CbPage);
 531                 return 1;
 532         }
 533
 534         return currPageCnt;
 535 }
 536
 537
 538 void SmsPluginCbMsgHandler::MakeCbMsg(SMS_CBMSG_PAGE_S CbPage, SMS_CBMSG_S *pCbMsg)
 539 {
 540         pCbMsg->cbMsgType = CbPage.cbMsgType;
 541         pCbMsg->msgId = CbPage.pageHeader.msgId;
 542         pCbMsg->classType = CbPage.pageHeader.dcs.classType;
 543         pCbMsg->codingScheme = CbPage.pageHeader.dcs.codingScheme;
 544         pCbMsg->recvTime = CbPage.pageHeader.recvTime;
 545
 546         cbPageMap::iterator it;
 547         string tmpStr ("");
 548
 549         for (unsigned int i = 0; i < pageList.size(); i++)
 550         {
 551                 if (pageList[i].geoScope == CbPage.pageHeader.serialNum.geoScope && pageList[i].msgCode == CbPage.pageHeader.serialNum.msgCode)
 552                 {
 553                         MSG_DEBUG("geoScope [%d], msgCode [%d]", pageList[i].geoScope, pageList[i].msgCode);
 554
 555                         if (pageList[i].msgId == CbPage.pageHeader.msgId)
 556                         {
 557                                 for (it = pageList[i].data.begin(); it != pageList[i].data.end(); it++)
 558                                 {
 559                                         tmpStr += it->second;
 560                                 }
 561                         }
 562                 }
 563         }
 564
 565         pCbMsg->msgLength = tmpStr.size();
 566
 567         memcpy(pCbMsg->msgData, tmpStr.c_str(), tmpStr.size());
 568         pCbMsg->msgData[tmpStr.size()] = '\0';
 569
 570         MSG_DEBUG("SIZE : [%d] TOTAL MSG : %s", tmpStr.size(), tmpStr.c_str());
 571 }
 572
 573
 574 void SmsPluginCbMsgHandler::convertCbMsgToMsginfo(SMS_CBMSG_S cbMsg, MSG_MESSAGE_INFO_S *pMsgInfo)
 575 {
 576         pMsgInfo->msgId = (msg_message_id_t)cbMsg.msgId;
 577
 578         pMsgInfo->folderId = MSG_CBMSGBOX_ID;
 579
 580         // Convert Type values
 581         pMsgInfo->msgType.mainType = MSG_SMS_TYPE;
 582
 583         if (cbMsg.cbMsgType == SMS_CBMSG_TYPE_CBS)
 584                 pMsgInfo->msgType.subType = MSG_CB_SMS;
 585         else if (cbMsg.cbMsgType == SMS_CBMSG_TYPE_JAVACBS)
 586                 pMsgInfo->msgType.subType = MSG_JAVACB_SMS;
 587
 588         switch(cbMsg.classType)
 589         {
 590                 case SMS_MSG_CLASS_0:
 591                         pMsgInfo->msgType.classType = MSG_CLASS_0;
 592                         break;
 593                 case SMS_MSG_CLASS_1:
 594                         pMsgInfo->msgType.classType = MSG_CLASS_1;
 595                         break;
 596                 case SMS_MSG_CLASS_2:
 597                         pMsgInfo->msgType.classType = MSG_CLASS_2;
 598                         break;
 599                 case SMS_MSG_CLASS_3:
 600                         pMsgInfo->msgType.classType = MSG_CLASS_3;
 601                         break;
 602                 default:
 603                         pMsgInfo->msgType.classType = MSG_CLASS_NONE;
 604         }
 605
 606         pMsgInfo->storageId = MSG_STORAGE_PHONE;
 607         pMsgInfo->networkStatus = MSG_NETWORK_RECEIVED;
 608         pMsgInfo->bRead = false;
 609         pMsgInfo->bProtected = false;
 610         pMsgInfo->priority = MSG_MESSAGE_PRIORITY_NORMAL;
 611         pMsgInfo->direction = MSG_DIRECTION_TYPE_MT;
 612
 613         // Temporary
 614         pMsgInfo->nAddressCnt = 1;
 615
 616         pMsgInfo->addressList[0].addressType = MSG_ADDRESS_TYPE_UNKNOWN;
 617         pMsgInfo->addressList[0].recipientType = MSG_RECIPIENTS_TYPE_UNKNOWN;
 618
 619         getDisplayName(cbMsg.msgId, pMsgInfo->addressList[0].addressVal);
 620         MSG_DEBUG("%s", pMsgInfo->addressList[0].addressVal);
 621
 622         pMsgInfo->msgPort.valid = false;
 623         pMsgInfo->msgPort.dstPort = 0;
 624         pMsgInfo->msgPort.srcPort = 0;
 625
 626         pMsgInfo->displayTime = cbMsg.recvTime;
 627         MSG_DEBUG("recvTime is %s", ctime(&pMsgInfo->displayTime));
 628
 629         int bufSize = cbMsg.msgLength*2;
 630
 631         char tmpBuf[bufSize];
 632         memset(tmpBuf, 0x00, sizeof(tmpBuf));
 633
 634         MSG_DEBUG("LENGTH %d CB MSG %s", cbMsg.msgLength, cbMsg.msgData);
 635
 636         SMS_LANG_INFO_S langInfo = {0};
 637
 638         langInfo.bSingleShift = false;
 639         langInfo.bLockingShift = false;
 640
 641         // Convert Data values
 642         if (cbMsg.codingScheme == SMS_CHARSET_7BIT)
 643                 pMsgInfo->dataSize = SmsPluginTextConvert::instance()->convertGSM7bitToUTF8((unsigned char*)tmpBuf, bufSize, (unsigned char*)cbMsg.msgData, cbMsg.msgLength, &langInfo);
 644         else if (cbMsg.codingScheme == SMS_CHARSET_UCS2)
 645                 pMsgInfo->dataSize = SmsPluginTextConvert::instance()->convertUCS2ToUTF8((unsigned char*)tmpBuf, bufSize, (unsigned char*)cbMsg.msgData, cbMsg.msgLength);
 646
 647         if (pMsgInfo->dataSize > MAX_MSG_TEXT_LEN)
 648         {
 649                 pMsgInfo->bTextSms = false;
 650
 651                 // Save Message Data into File
 652                 char fileName[MAX_COMMON_INFO_SIZE+1];
 653                 memset(fileName, 0x00, sizeof(fileName));
 654
 655                 if (MsgCreateFileName(fileName) == false)
 656                         THROW(MsgException::FILE_ERROR, "MsgCreateFileName error");
 657
 658                 MSG_DEBUG("Save Message Data into file : size[%d] name[%s]\n", pMsgInfo->dataSize, fileName);
 659                 if (MsgWriteIpcFile(fileName, tmpBuf, pMsgInfo->dataSize) == false)
 660                         THROW(MsgException::FILE_ERROR, "MsgWriteIpcFile error");
 661
 662                 strncpy(pMsgInfo->msgData, fileName, MAX_MSG_DATA_LEN);
 663         }
 664         else
 665         {
 666                 pMsgInfo->bTextSms = true;
 667
 668                 memset(pMsgInfo->msgText, 0x00, sizeof(pMsgInfo->msgText));
 669                 memcpy(pMsgInfo->msgText, tmpBuf, pMsgInfo->dataSize);
 670         }
 671 }
 672
 673
 674 void SmsPluginCbMsgHandler::convertEtwsMsgToMsginfo(SMS_CBMSG_PAGE_S EtwsMsg, MSG_MESSAGE_INFO_S *pMsgInfo)
 675 {
 676         pMsgInfo->msgId = (msg_message_id_t)EtwsMsg.pageHeader.msgId;
 677
 678         pMsgInfo->folderId = MSG_CBMSGBOX_ID;
 679
 680         // Convert Type values
 681         pMsgInfo->msgType.mainType = MSG_SMS_TYPE;
 682
 683         if (EtwsMsg.cbMsgType == SMS_CBMSG_TYPE_ETWS)
 684                 pMsgInfo->msgType.subType = MSG_ETWS_SMS;
 685
 686         pMsgInfo->storageId = MSG_STORAGE_PHONE;
 687         pMsgInfo->networkStatus = MSG_NETWORK_RECEIVED;
 688         pMsgInfo->bRead = false;
 689         pMsgInfo->bProtected = false;
 690         pMsgInfo->priority = MSG_MESSAGE_PRIORITY_NORMAL;
 691         pMsgInfo->direction = MSG_DIRECTION_TYPE_MT;
 692
 693         // Temporary
 694         pMsgInfo->nAddressCnt = 1;
 695
 696         pMsgInfo->addressList[0].addressType = MSG_ADDRESS_TYPE_UNKNOWN;
 697         pMsgInfo->addressList[0].recipientType = MSG_RECIPIENTS_TYPE_UNKNOWN;
 698
 699         getDisplayName(EtwsMsg.pageHeader.msgId, pMsgInfo->addressList[0].addressVal);
 700         MSG_DEBUG("%s", pMsgInfo->addressList[0].addressVal);
 701
 702         pMsgInfo->msgPort.valid = false;
 703         pMsgInfo->msgPort.dstPort = 0;
 704         pMsgInfo->msgPort.srcPort = 0;
 705
 706         pMsgInfo->displayTime = EtwsMsg.pageHeader.recvTime;
 707         MSG_DEBUG("recvTime is %s", ctime(&pMsgInfo->displayTime));
 708         MSG_DEBUG("LENGTH %d", EtwsMsg.pageLength);
 709         pMsgInfo->bTextSms = true;
 710         pMsgInfo->dataSize = EtwsMsg.pageLength;
 711         memset(pMsgInfo->msgData, 0x00, sizeof(pMsgInfo->msgData));
 712         memcpy(pMsgInfo->msgData, EtwsMsg.pageData, pMsgInfo->dataSize);
 713 }
 714
 715 void SmsPluginCbMsgHandler::addToPageLiat(SMS_CBMSG_PAGE_S CbPage)
 716 {
 717         CB_PAGE_INFO_S tmpInfo;
 718
 719         tmpInfo.geoScope = CbPage.pageHeader.serialNum.geoScope;
 720         tmpInfo.msgCode = CbPage.pageHeader.serialNum.msgCode;
 721         tmpInfo.updateNum = CbPage.pageHeader.serialNum.updateNum;
 722         tmpInfo.msgId = CbPage.pageHeader.msgId;
 723         tmpInfo.totalPages = CbPage.pageHeader.totalPages;
 724
 725         tmpInfo.pageCnt = 1;
 726         tmpInfo.totalSize = CbPage.pageLength;
 727
 728         pair<unsigned char, string> newData(CbPage.pageHeader.page, CbPage.pageData);
 729         tmpInfo.data.insert(newData);
 730
 731         MSG_DEBUG("MSG DATA : %s", CbPage.pageData);
 732         MSG_DEBUG("PAIR DATA [%d] : %s", newData.first, newData.second.c_str());
 733
 734         pageList.push_back(tmpInfo);
 735 }
 736
 737
 738 void SmsPluginCbMsgHandler::removeFromPageList(SMS_CBMSG_PAGE_S CbPage)
 739 {
 740         unsigned int index;
 741
 742         for (index = 0; index < pageList.size(); index++)
 743         {
 744                 if (pageList[index].geoScope == CbPage.pageHeader.serialNum.geoScope && pageList[index].msgCode == CbPage.pageHeader.serialNum.msgCode)
 745                 {
 746                         MSG_DEBUG("geoScope [%d], msgCode [%d]", pageList[index].geoScope, pageList[index].msgCode);
 747
 748                         if (pageList[index].msgId == CbPage.pageHeader.msgId) break;
 749                 }
 750         }
 751
 752         MSG_DEBUG("remove index [%d]", index);
 753
 754         pageList.erase(pageList.begin()+index);
 755 }
 756
 757
 758 void SmsPluginCbMsgHandler::decodeCbMsgDCS(unsigned char dcsData, const unsigned char *pMsgData, SMS_CBMSG_DCS_S* pDcs)
 759 {
 760         pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
 761         pDcs->classType = SMS_MSG_CLASS_NONE;
 762         pDcs->bCompressed = false;
 763         pDcs->codingScheme = SMS_CHARSET_7BIT;
 764         pDcs->langType = SMS_CBMSG_LANG_UNSPECIFIED;
 765         memset(pDcs->iso639Lang, 0x00, sizeof(pDcs->iso639Lang));
 766         pDcs->bUDH = false;
 767         pDcs->rawData = dcsData;
 768
 769         unsigned char codingGrp = (dcsData & 0xF0) >> 4;
 770
 771         switch (codingGrp)
 772         {
 773                 case 0x00 :
 774                 case 0x02 :
 775                 case 0x03 :
 776                 {
 777                         pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
 778                         pDcs->langType = (SMS_CBMSG_LANG_TYPE_T)dcsData;
 779                 }
 780                 break;
 781
 782                 case 0x01 :
 783                 {
 784                         if (dcsData == 0x10 || dcsData == 0x11)
 785                         {
 786                                 pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
 787                                 pDcs->codingScheme = (dcsData & 0x01) ? SMS_CHARSET_UCS2 : SMS_CHARSET_7BIT;
 788                                 pDcs->langType = SMS_CBMSG_LANG_ISO639;
 789
 790                                 if (pMsgData != NULL)
 791                                 {
 792                                         pDcs->iso639Lang[0] = pMsgData[0] & 0x7F;
 793                                         pDcs->iso639Lang[1] = (pMsgData[0] & 0x80) >> 7;
 794                                         pDcs->iso639Lang[1] |= (pMsgData[1] & 0x3F) << 1;
 795                                         pDcs->iso639Lang[2]  = 0x13; /* CR char in GSM 7-bit Alphabet */
 796                                 }
 797                                 else
 798                                 {
 799                                         /* Default it to English if pMsgData is NULL */
 800                                         pDcs->iso639Lang[0] = 0x45;  /* E */
 801                                         pDcs->iso639Lang[1] = 0x4E;  /* N */
 802                                         pDcs->iso639Lang[2] = 0x13;  /* CR */
 803                                 }
 804                         }
 805                 }
 806                 break;
 807
 808                 case 0x04 :
 809                 case 0x05 :
 810                 case 0x06 :
 811                 case 0x07 :
 812                 {
 813                         pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
 814
 815                         pDcs->bCompressed = (dcsData & 0x20) ? true : false;
 816
 817                         if (dcsData & 0x10)
 818                                 pDcs->classType = (SMS_MSG_CLASS_T)(dcsData & 0x03);
 819
 820                         pDcs->codingScheme = (SMS_CODING_SCHEME_T)(dcsData & 0x0C);
 821                 }
 822                 break;
 823
 824                 case 0x09 :
 825                 {
 826                         pDcs->bUDH = true;
 827                 }
 828                 break;
 829
 830                 case 0x14 :
 831                 {
 832                         pDcs->codingGroup = SMS_CBMSG_CODGRP_WAP;
 833                 }
 834                 break;
 835
 836                 case 0x15 :
 837                 {
 838                         pDcs->codingGroup = SMS_CBMSG_CODGRP_CLASS_CODING;
 839                         pDcs->codingScheme = (dcsData & 0x04) ? SMS_CHARSET_UCS2 : SMS_CHARSET_7BIT;
 840                         pDcs->classType = (MSG_CLASS_TYPE_T)(dcsData & 0x03);
 841                 }
 842                 break;
 843         }
 844 }
 845
 846
 847 void SmsPluginCbMsgHandler::convertLangType(SMS_CBMSG_LANG_TYPE_T InType , MSG_CB_LANGUAGE_TYPE_T *pOutType)
 848 {
 849         switch (InType)
 850         {
 851                 case SMS_CBMSG_LANG_GERMAN :
 852                         *pOutType = MSG_CBLANG_TYPE_GER;
 853                 break;
 854
 855                 case SMS_CBMSG_LANG_ENGLISH :
 856                         *pOutType = MSG_CBLANG_TYPE_ENG;
 857                 break;
 858
 859                 case SMS_CBMSG_LANG_ITALIAN :
 860                         *pOutType = MSG_CBLANG_TYPE_ITA;
 861                 break;
 862
 863                 case SMS_CBMSG_LANG_FRENCH :
 864                         *pOutType = MSG_CBLANG_TYPE_FRE;
 865                 break;
 866
 867                 case SMS_CBMSG_LANG_SPANISH :
 868                         *pOutType = MSG_CBLANG_TYPE_SPA;
 869                 break;
 870
 871                 case SMS_CBMSG_LANG_DUTCH :
 872                         *pOutType = MSG_CBLANG_TYPE_NED;
 873                 break;
 874
 875                 case SMS_CBMSG_LANG_SWEDISH :
 876                         *pOutType = MSG_CBLANG_TYPE_SWE;
 877                 break;
 878
 879                 case SMS_CBMSG_LANG_PORTUGUESE :
 880                         *pOutType = MSG_CBLANG_TYPE_POR;
 881                 break;
 882
 883                 case SMS_CBMSG_LANG_TURKISH :
 884                         *pOutType = MSG_CBLANG_TYPE_TUR;
 885                 break;
 886
 887                 default :
 888                         *pOutType = MSG_CBLANG_TYPE_MAX;
 889                 break;
 890         }
 891 }
 892
 893
 894 unsigned long SmsPluginCbMsgHandler::getRecvTime()
 895 {
 896         time_t recvTime;
 897
 898         recvTime = time(NULL);
 899
 900         return (unsigned long)recvTime;
 901 }
 902
 903
 904 void SmsPluginCbMsgHandler::getDisplayName(unsigned short       MsgId, char *pDisplayName)
 905 {
 906         int MsgIdCnt = MsgSettingGetInt(CB_CHANNEL_COUNT);
 907
 908         char from[128];
 909         char to[128];
 910
 911         for (int i = 0; i < MsgIdCnt; i++)
 912         {
 913                 memset(from, 0x00, sizeof(from));
 914                 sprintf(from, "%s/%d", CB_CHANNEL_ID_FROM, i);
 915
 916                 memset(to, 0x00, sizeof(to));
 917                 sprintf(to, "%s/%d", CB_CHANNEL_ID_TO, i);
 918
 919                 if (MsgId >= MsgSettingGetInt(from) && MsgId <= MsgSettingGetInt(to))
 920                 {
 921                         MSG_DEBUG("FIND MSG ID = [%d]", MsgId);
 922 #if 0
 923                         memset(keyName, 0x00, sizeof(keyName));
 924                         sprintf(keyName, "%s/%d", CB_CHANNEL_NAME, i);
 925
 926                         memset(strTmp, 0x00, sizeof(strTmp));
 927
 928                         channelName = MsgSettingGetString(keyName);
 929
 930                         strncpy(strTmp, channelName, CB_CHANNEL_NAME_MAX);
 931
 932                         if (channelName) {
 933                                 free(channelName);
 934                                 channelName = NULL;
 935                         }
 936
 937                         if (strlen(strTmp) > 0)
 938                                 sprintf(pDisplayName, "[%s]", strTmp);
 939                         else
 940                                 sprintf(pDisplayName, "[%d]", MsgId);
 941 #else
 942                         sprintf(pDisplayName, "[%d]", MsgId);
 943 #endif
 944
 945                         return;
 946                 }
 947         }
 948
 949         sprintf(pDisplayName, "[%d]", MsgId);
 950 }
 951