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