plugin/sms_plugin/SmsPluginCbMsgHandler.cpp

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