src/DataControl/SqlDataControlConsumer.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <cassert>
  19 #include <Commons/Exception.h>
  20 #include "DataType.h"
  21 #include "SqlDataControlConsumer.h"
  22 #include <appsvc/appsvc.h>
  23 #include <string>
  24 #include <vector>
  25 #include <aul/aul.h>
  26 #include <sstream>
  27 #include <package-manager.h>
  28 #include <app.h>
  29 // to get package name by appid
  30 #include <app_info.h>
  31 #include <app_manager.h>
  32 // To get ppid
  33 #include <unistd.h>
  34 #include <security-server.h>
  35 #include <sstream>
  36 #include "DataControlAsyncCallbackManager.h"
  37
  38 namespace DeviceAPI {
  39 namespace DataControl {
  40
  41
  42 namespace {
  43
  44 static const char OSP_V_CALLER_TYPE_OSP[] = "osp";
  45 static const char OSP_V_LAUNCH_TYPE_LAUNCH[] = "launch";
  46 static const char OSP_V_LAUNCH_TYPE_APPCONTROL[] = "appcontrol";
  47 static const char OSP_V_LAUNCH_TYPE_DATACONTROL[] = "datacontrol";
  48 static const char OSP_V_LAUNCH_TYPE_CONDTION[] = "condition";
  49 static const char OSP_V_REQUEST_TYPE_SQL_QUERY[] = "sql_query";
  50 static const char OSP_V_REQUEST_TYPE_SQL_INSERT[] = "sql_insert";
  51 static const char OSP_V_REQUEST_TYPE_SQL_UPDATE[] = "sql_update";
  52 static const char OSP_V_REQUEST_TYPE_SQL_DELETE[] = "sql_delete";
  53 static const char OSP_V_REQUEST_TYPE_MAP_QEURY[] = "map_query";
  54 static const char OSP_V_REQUEST_TYPE_MAP_INSERT[] = "map_insert";
  55 static const char OSP_V_REQUEST_TYPE_MAP_UPDATE[] = "map_update";
  56 static const char OSP_V_REQUEST_TYPE_MAP_DELETE[] = "map_delete";
  57 static const char BUNDLE_KEY_WINDOW[] = "__APP_SVC_K_WIN_ID__";
  58
  59
  60 #define OSP_K_CALLER_TYPE   "__OSP_CALLER_TYPE__"
  61 #define OSP_K_LAUNCH_TYPE   "__OSP_LAUNCH_TYPE__"
  62 #define OSP_K_ARG           "__OSP_ARGS__"
  63 #define OSP_K_COND          "__OSP_COND_NAME__"
  64 #define OSP_K_APPID         "__OSP_APPID__"
  65 #define OSP_K_REQUEST_ID    "__OSP_REQUEST_ID__"
  66 #define OSP_K_APPCONTROL_PROVIDER   "__OSP_APPCONTROL_PROVIDER__"
  67 #define OSP_K_APPCONTROL_OPERATION  "__OSP_APPCONTROL_OPERATION__"
  68 #define OSP_K_APPCONTROL_CATEGORY   "__OSP_APPCONTROL_CATEGORY__"
  69 #define OSP_K_APPCONTROL_MIME       "__OSP_APPCONTROL_MIME__"
  70 #define OSP_K_APPCONTROL_URI        "__OSP_APPCONTROL_URI__"
  71 #define OSP_K_DATACONTROL_PROVIDER      "__OSP_DATACONTROL_PROVIDER__"
  72 #define OSP_K_DATACONTROL_REQUEST_TYPE  "__OSP_DATACONTROL_REQUEST_TYPE__"
  73 #define RESULT_TRUE_FROM_OSP "1"
  74 #define RESULT_FALSE_FROM_OSP "0"
  75 #define OSP_K_DATACONTROL_PROTOCOL_VERSION  "__OSP_DATACONTROL_PROTOCOL_VERSION__"
  76 #define OSP_K_DATACONTROL_PROTOCOL_VERSION_VALUE "ver_2.1.0.3"
  77
  78 #define DATACONTROL_PROTOCOL_DIR_TOP  "/tmp/osp"
  79 #define DATACONTROL_PROTOCOL_DIR_MIDDLE  "/tmp/osp/data-control"
  80 #define DATACONTROL_PROTOCOL_DIR  "/tmp/osp/data-control/request"
  81
  82 static std::vector<std::string> getDataArrayFromBundle(bundle *b, std::string key)
  83 {
  84         std::vector<std::string> result;
  85         const char **array;
  86         int length = 0;
  87         int index = 0;
  88
  89         array = appsvc_get_data_array(b, key.c_str(), &length);
  90
  91         if (array == NULL || length == 0)
  92         {
  93                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Get result data fail from datacontrol provider");
  94         }
  95
  96         for (index = 0; index < length; index++)
  97         {
  98                 result.push_back(array[index]);
  99         }
 100
 101         return result;
 102 }
 103
 104
 105 static void sqldataControlSelectCallback(bundle* b, int request_code, appsvc_result_val res, void* data)
 106 {
 107         LoggerD("Enter");
 108
 109         EventSelectPendingEvent *pendingEvent = NULL;
 110         SQLDataControlConsumer *consumer = NULL;
 111         EventSelectPtr event;
 112         const char *bundleKey = NULL;
 113
 114         try
 115         {
 116                 if (b == NULL)
 117                 {
 118                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Get result fail from datacontrol provider");
 119                 }
 120
 121         bundleKey = appsvc_get_data(b, OSP_K_REQUEST_ID);
 122
 123                 if (bundleKey == NULL)
 124                 {
 125                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Get key fail from datacontrol provider");
 126                 }
 127
 128                 pendingEvent = (EventSelectPendingEvent *)DataControlAsyncCallbackManagerSingleton::Instance().removeSQLUserData(bundleKey);
 129                 consumer = (SQLDataControlConsumer*)pendingEvent->getThisObject();
 130
 131                 if (DataControlAsyncCallbackManagerSingleton::Instance().isSQLDataControlGC((void*)consumer))
 132                 {
 133                         LoggerD("private object is garbage collected");
 134                         delete pendingEvent;
 135                         return;
 136                 }
 137                 event = pendingEvent->getEvent();
 138
 139                 std::vector<std::string> result = getDataArrayFromBundle(b, OSP_K_ARG);
 140
 141                 for (size_t index = 0; index < result.size(); index++)
 142                 {
 143                         LoggerD(result[index]);
 144                 }
 145
 146                 if (result.size() < 3)
 147                 {
 148                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid result from datacontrol provider");
 149                 }
 150
 151                 // 0 : result true or false??
 152                 if (RESULT_TRUE_FROM_OSP != result[0])
 153                 {
 154                         // 1 : error msg
 155                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, result[1]);
 156                 }
 157
 158                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::None);
 159                 // 2 : result set file path
 160                 event->setResultSetPath(result[2]);
 161
 162         }
 163         catch (const WrtDeviceApis::Commons::Exception& ex)
 164         {
 165                 LoggerE("Exception: " << ex.GetMessage());
 166
 167                 if (event.Get() == NULL)
 168                 {
 169                         LoggerD("event removed, invalid cb");
 170                         return;
 171                 }
 172
 173                 event->setExceptionCode(ex.getCode());
 174                 event->setErrorMsg(ex.GetMessage());
 175         }
 176         consumer->handlePendingEvent(event);
 177
 178         if (pendingEvent)
 179         {
 180                 delete pendingEvent;
 181         }
 182
 183 }
 184
 185 static void sqldataControlInsertCallback(bundle* b, int request_code, appsvc_result_val res, void* data)
 186 {
 187         LoggerD("Enter");
 188
 189
 190         EventInsertPendingEvent *pendingEvent = NULL;
 191         SQLDataControlConsumer *consumer = NULL;
 192         EventInsertPtr event;
 193         const char *bundleKey = NULL;
 194
 195         try
 196         {
 197                 if (b == NULL)
 198                 {
 199                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Get result fail from datacontrol provider");
 200                 }
 201
 202         bundleKey = appsvc_get_data(b, OSP_K_REQUEST_ID);
 203
 204                 if (bundleKey == NULL)
 205                 {
 206                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Get key fail from datacontrol provider");
 207                 }
 208
 209                 pendingEvent = (EventInsertPendingEvent *)DataControlAsyncCallbackManagerSingleton::Instance().removeSQLUserData(bundleKey);
 210                 consumer = (SQLDataControlConsumer*)pendingEvent->getThisObject();
 211
 212                 if (DataControlAsyncCallbackManagerSingleton::Instance().isSQLDataControlGC((void*)consumer))
 213                 {
 214                         LoggerD("private object is garbage collected");
 215                         delete pendingEvent;
 216                         return;
 217                 }
 218
 219                 event = pendingEvent->getEvent();
 220
 221                 std::vector<std::string> result = getDataArrayFromBundle(b, OSP_K_ARG);
 222
 223                 for (size_t index = 0; index < result.size(); index++)
 224                 {
 225                         LoggerD(result[index]);
 226                 }
 227
 228                 if (result.size() < 2)
 229                 {
 230                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid result from datacontrol provider");
 231                 }
 232
 233                 // 0 : result true or false??
 234                 if (RESULT_TRUE_FROM_OSP != result[0])
 235                 {
 236                         // 1 : error msg
 237                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, result[1]);
 238                 }
 239
 240                 // 2 : insertrowid
 241                 std::stringstream sstr(result[2]);
 242                 long insertRowid = 0;
 243                 sstr >> insertRowid;
 244                 LoggerD(result[2] << insertRowid);
 245                 event->setRowId(insertRowid);
 246                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::None);
 247
 248         }
 249         catch (const WrtDeviceApis::Commons::Exception& ex)
 250         {
 251                 LoggerE("Exception: " << ex.GetMessage());
 252
 253                 if (event.Get() == NULL)
 254                 {
 255                         LoggerD("event removed, invalid cb");
 256                         return;
 257                 }
 258
 259                 event->setExceptionCode(ex.getCode());
 260                 event->setErrorMsg(ex.GetMessage());
 261         }
 262         consumer->handlePendingEvent(event);
 263
 264         if (pendingEvent)
 265         {
 266                 delete pendingEvent;
 267         }
 268
 269 }
 270
 271 static void sqldataControlDeleteCallback(bundle* b, int request_code, appsvc_result_val res, void* data)
 272 {
 273         LoggerD("Enter");
 274
 275         EventDeletePendingEvent* pendingEvent = NULL;
 276         SQLDataControlConsumer *consumer = NULL;
 277         EventDeletePtr event;
 278         const char* bundleKey = NULL;
 279
 280         try
 281         {
 282                 if (b == NULL)
 283                 {
 284                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Get result fail from datacontrol provider");
 285                 }
 286
 287         bundleKey = appsvc_get_data(b, OSP_K_REQUEST_ID);
 288
 289                 if (bundleKey == NULL)
 290                 {
 291                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Get key fail from datacontrol provider");
 292                 }
 293
 294                 pendingEvent = (EventDeletePendingEvent *)DataControlAsyncCallbackManagerSingleton::Instance().removeSQLUserData(bundleKey);
 295                 consumer = (SQLDataControlConsumer*)pendingEvent->getThisObject();
 296
 297                 if (DataControlAsyncCallbackManagerSingleton::Instance().isSQLDataControlGC((void*)consumer))
 298                 {
 299                         LoggerD("private object is garbage collected");
 300                         delete pendingEvent;
 301                         return;
 302                 }
 303
 304                 event = pendingEvent->getEvent();
 305
 306                 std::vector<std::string> result = getDataArrayFromBundle(b, OSP_K_ARG);
 307
 308                 for (size_t index = 0; index < result.size(); index++)
 309                 {
 310                         LoggerD(result[index]);
 311                 }
 312
 313                 if (result.size() < 2)
 314                 {
 315                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid result from datacontrol provider");
 316                 }
 317
 318                 // 0 : result true or false??
 319                 if (RESULT_TRUE_FROM_OSP != result[0])
 320                 {
 321                         // 1 : error msg
 322                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, result[1]);
 323                 }
 324
 325                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::None);
 326
 327
 328         }
 329         catch (const WrtDeviceApis::Commons::Exception& ex)
 330         {
 331                 LoggerE("Exception: " << ex.GetMessage());
 332
 333                 if (event.Get() == NULL)
 334                 {
 335                         LoggerD("event removed, invalid cb");
 336                         return;
 337                 }
 338
 339                 event->setExceptionCode(ex.getCode());
 340                 event->setErrorMsg(ex.GetMessage());
 341         }
 342         consumer->handlePendingEvent(event);
 343
 344         if (pendingEvent)
 345         {
 346                 delete pendingEvent;
 347         }
 348 }
 349
 350 static void sqldataControlUpdateCallback(bundle* b, int request_code, appsvc_result_val res, void* data)
 351 {
 352         LoggerD("Enter");
 353
 354         EventUpdatePendingEvent* pendingEvent = NULL;
 355         SQLDataControlConsumer *consumer = NULL;
 356         EventUpdatePtr event;
 357         const char *bundleKey = NULL;
 358
 359         try
 360         {
 361                 if (b == NULL)
 362                 {
 363                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Get result fail from datacontrol provider");
 364                 }
 365
 366         bundleKey = appsvc_get_data(b, OSP_K_REQUEST_ID);
 367
 368                 if (bundleKey == NULL)
 369                 {
 370                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Get key fail from datacontrol provider");
 371                 }
 372
 373                 pendingEvent = (EventUpdatePendingEvent *)DataControlAsyncCallbackManagerSingleton::Instance().removeSQLUserData(bundleKey);
 374                 consumer = (SQLDataControlConsumer*)pendingEvent->getThisObject();
 375
 376                 if (DataControlAsyncCallbackManagerSingleton::Instance().isSQLDataControlGC((void*)consumer))
 377                 {
 378                         LoggerD("private object is garbage collected");
 379                         delete pendingEvent;
 380                         return;
 381                 }
 382
 383                 event = pendingEvent->getEvent();
 384
 385                 std::vector<std::string> result = getDataArrayFromBundle(b, OSP_K_ARG);
 386
 387                 for (size_t index = 0; index < result.size(); index++)
 388                 {
 389                         LoggerD(result[index]);
 390                 }
 391
 392                 if (result.size() < 2)
 393                 {
 394                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid result from datacontrol provider");
 395                 }
 396
 397                 // 0 : result true or false??
 398                 if (RESULT_TRUE_FROM_OSP != result[0])
 399                 {
 400                         // 1 : error msg
 401                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, result[1]);
 402                 }
 403
 404                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::None);
 405
 406         }
 407         catch (const WrtDeviceApis::Commons::Exception& ex)
 408         {
 409                 LoggerE("Exception: " << ex.GetMessage());
 410
 411                 if (event.Get() == NULL)
 412                 {
 413                         LoggerD("event removed, invalid cb");
 414                         return;
 415                 }
 416
 417                 event->setExceptionCode(ex.getCode());
 418                 event->setErrorMsg(ex.GetMessage());
 419         }
 420         consumer->handlePendingEvent(event);
 421
 422         if (pendingEvent)
 423         {
 424                 delete pendingEvent;
 425         }
 426 }
 427
 428 static void sqldataControlCommonCallback(bundle* b, int request_code, appsvc_result_val res, void* data)
 429 {
 430         LoggerD("Enter");
 431
 432         if (b == NULL)
 433         {
 434                 LoggerD("Bundle null, Error");
 435                 return;
 436         }
 437
 438         const char *reqType = appsvc_get_data(b, OSP_K_DATACONTROL_REQUEST_TYPE);
 439
 440         if (reqType == NULL)
 441         {
 442                 LoggerD("UnkownRequest");
 443                 return;
 444         }
 445
 446         std::istringstream buffer(reqType);
 447         int reqTypeInt = 0;
 448
 449         buffer >> reqTypeInt;
 450
 451
 452         LoggerD(reqTypeInt);
 453
 454         switch (reqTypeInt)
 455         {
 456                 case _DATACONTROL_REQUEST_TYPE_SQL_QUERY:
 457                         sqldataControlSelectCallback(b, request_code, res, data);
 458                         break;
 459                 case _DATACONTROL_REQUEST_TYPE_SQL_INSERT:
 460                         sqldataControlInsertCallback(b, request_code, res, data);
 461                         break;
 462                 case _DATACONTROL_REQUEST_TYPE_SQL_DELETE:
 463                         sqldataControlDeleteCallback(b, request_code, res, data);
 464                         break;
 465                 case _DATACONTROL_REQUEST_TYPE_SQL_UPDATE:
 466                         sqldataControlUpdateCallback(b, request_code, res, data);
 467                         break;
 468                 default:
 469                         LoggerD("Unknown Request");
 470         }
 471 }
 472
 473 }
 474
 475 SQLDataControlConsumer::SQLDataControlConsumer(std::string& provId, std::string& dataId, std::string& type)
 476 {
 477         LoggerD("Enter");
 478
 479         m_type = type;
 480         m_dataId = dataId;
 481         m_providerId = provId;
 482
 483         m_appId = getApplicationId(provId);
 484         m_ProviderPkgId = getProviderPkgId(m_appId);
 485         security_server_app_give_access(m_ProviderPkgId.c_str(), -1);
 486
 487         m_currentAppId = getCurrentApplicationId();
 488         createResultDir();
 489         DataControlAsyncCallbackManagerSingleton::Instance().setSQLDataControlGC((void*)this, false);
 490 }
 491
 492 SQLDataControlConsumer::~SQLDataControlConsumer()
 493 {
 494         LoggerD("Enter");
 495         DataControlAsyncCallbackManagerSingleton::Instance().setSQLDataControlGC((void*)this, true);
 496 }
 497
 498 DPL::Mutex SQLDataControlConsumer::m_mutex;
 499 std::vector<unsigned int> SQLDataControlConsumer::m_currentReqIds;
 500
 501 std::string SQLDataControlConsumer::getCurrentApplicationId()
 502 {
 503         char *app_id = NULL;
 504         std::string appId = "";
 505         int parent_pid = getppid();
 506         LoggerD("parent pid : " << parent_pid);
 507         int ret = app_manager_get_app_id(parent_pid, &app_id);
 508
 509         if((ret != APP_ERROR_NONE) || (app_id == NULL))
 510         {
 511                 LoggerE("Can not get app id from current pid (" << ret << ")");
 512                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "could not get information about application");
 513         }
 514         appId = app_id;
 515         free(app_id);
 516         return appId;
 517 }
 518
 519 void SQLDataControlConsumer::removeReqId(unsigned int reqId)
 520 {
 521         bool remove = false;
 522
 523         std::vector<unsigned int>::iterator it, found;
 524
 525         for (it = m_currentReqIds.begin(); it != m_currentReqIds.end(); ++it)
 526         {
 527                 if (*it == reqId)
 528                 {
 529                         found = it;
 530                         remove = true;
 531                 }
 532         }
 533
 534         if (remove)
 535         {
 536                 DPL::Mutex::ScopedLock lock(&m_mutex);
 537                 m_currentReqIds.erase(found);
 538         }
 539 }
 540
 541 bool SQLDataControlConsumer::checkReqIdUniqueness(unsigned int reqId)
 542 {
 543         std::string reqIdStr;
 544         std::stringstream ssReqId;
 545
 546         ssReqId << reqId;
 547         reqIdStr = ssReqId.str();
 548         return DataControlAsyncCallbackManagerSingleton::Instance().checkReqIdUnique(reqIdStr);
 549 }
 550
 551
 552 std::string SQLDataControlConsumer::getDataId()
 553 {
 554         return m_dataId;
 555 }
 556
 557 std::string SQLDataControlConsumer::getProviderId()
 558 {
 559         return m_providerId;
 560 }
 561
 562 std::string SQLDataControlConsumer::getType()
 563 {
 564         return m_type;
 565 }
 566
 567 std::string SQLDataControlConsumer::getProviderPkgId(const std::string& appId)
 568 {
 569         char* pkgId = NULL;
 570         app_info_h handle = NULL;
 571
 572         if (m_ProviderPkgId.length() != 0)
 573         {
 574                 return m_ProviderPkgId;
 575         }
 576
 577         int ret = app_manager_get_app_info(appId.c_str(), &handle);
 578
 579         if (ret != APP_ERROR_NONE)
 580         {
 581                 LoggerD("Fail to get appinfo");
 582                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "get appId error");
 583         }
 584
 585         ret = app_info_get_package(handle, &pkgId);
 586
 587         if ((ret != APP_ERROR_NONE) || (pkgId == NULL))
 588         {
 589                 LoggerD("Fail to get pkg_name");
 590                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "get pkdid error");
 591         }
 592         m_ProviderPkgId = pkgId;
 593         app_info_destroy(handle);
 594         free(pkgId);
 595         return m_ProviderPkgId;
 596 }
 597
 598 std::string SQLDataControlConsumer::getApplicationId(const std::string& provId)
 599 {
 600         std::string appIdStr = "";
 601
 602         char* appId = NULL;
 603         char* access = NULL;
 604         const char *passId = provId.c_str();
 605
 606         if (m_appId.length() == 0)
 607         {
 608
 609                 if(     pkgmgr_datacontrol_get_info(passId, OSP_PKGINFO_SQL_TYPE, &appId, &access) < 0)
 610                 {
 611                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "get appId error");
 612                 }
 613
 614                 if (appId)
 615                 {
 616                         appIdStr = appId;
 617                         free(appId);
 618                 }
 619
 620                 if (access)
 621                 {
 622                         free(access);
 623                 }
 624
 625                 m_appId = appIdStr;
 626
 627
 628         }
 629         return m_appId;
 630
 631 }
 632
 633 std::string SQLDataControlConsumer::generateFileName(unsigned int reqId)
 634 {
 635         std::stringstream ssdata;
 636         ssdata.str("");
 637         ssdata << reqId;
 638         std::string parent = DATACONTROL_PROTOCOL_DIR;
 639         std::string filename = parent  + "/" + m_currentAppId + ssdata.str();
 640         return filename;
 641 }
 642
 643 void SQLDataControlConsumer::saveArrayToFile(std::string filename, RowData *rowData)
 644 {
 645         std::fstream insertUpdateFile;
 646         std::map<std::string, std::string>::iterator it;
 647         int strLength = 0;
 648         insertUpdateFile.open(filename.c_str(), std::ios::out | std::ios::binary);
 649
 650         if (!insertUpdateFile.is_open())
 651         {
 652                 LoggerD("fail open" << filename);
 653                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "DataControl IPC Error");
 654         }
 655
 656         for (it = rowData->m_Data.begin(); it != rowData->m_Data.end(); ++it)
 657         {
 658                 strLength = it->first.size();
 659                 insertUpdateFile.write((const char*)&strLength, sizeof(int));
 660                 insertUpdateFile.write(it->first.c_str(), strLength);
 661
 662                 strLength = it->second.size();
 663                 insertUpdateFile.write((const char*)&strLength, sizeof(int));
 664                 insertUpdateFile.write(it->second.c_str(), strLength);
 665         }
 666
 667         insertUpdateFile.close();
 668
 669 }
 670 void SQLDataControlConsumer::addArrayToBundle(bundle* passData, std::vector<std::string>& array)
 671 {
 672         size_t arraySize = array.size();
 673
 674         if (arraySize == 0)
 675         {
 676                 ThrowMsg(WrtDeviceApis::Commons::AlreadyInUseException, "size = 0");
 677         }
 678
 679         const char** arr = NULL;
 680         arr = (const char**)calloc(sizeof(char*), arraySize);
 681
 682         if (arr == NULL)
 683         {
 684                 ThrowMsg(WrtDeviceApis::Commons::AlreadyInUseException, "null");
 685         }
 686
 687         for (size_t index = 0; index < arraySize; index++)
 688         {
 689                 arr[index] = array[index].c_str();
 690         }
 691
 692
 693         bundle_add_str_array(passData, OSP_K_ARG, arr, arraySize);
 694
 695         free(arr);
 696         arr = NULL;
 697 }
 698
 699
 700 void SQLDataControlConsumer::handlePendingEvent(const EventInsertPtr& event)
 701 {
 702         LoggerD("OK");
 703         WrtDeviceApis::Commons::EventRequestReceiver<EventInsert>::ManualAnswer(event);
 704         try {
 705                 CommonPendingEvent* userData = (CommonPendingEvent*)DataControlAsyncCallbackManagerSingleton::Instance().getRemainingSQLOperation();
 706
 707                 if (userData)
 708                 {
 709                         SendAppControlLaunchToProvider(userData);
 710                 }
 711         }
 712         catch (const WrtDeviceApis::Commons::Exception& ex)
 713         {
 714                 LoggerE("Exception: " << ex.GetMessage());
 715         }
 716
 717 }
 718 void SQLDataControlConsumer::handlePendingEvent(const EventDeletePtr& event)
 719 {
 720         WrtDeviceApis::Commons::EventRequestReceiver<EventDelete>::ManualAnswer(event);
 721         try {
 722                 CommonPendingEvent* userData = (CommonPendingEvent*)DataControlAsyncCallbackManagerSingleton::Instance().getRemainingSQLOperation();
 723
 724                 if (userData)
 725                 {
 726                         SendAppControlLaunchToProvider(userData);
 727                 }
 728         }
 729         catch (const WrtDeviceApis::Commons::Exception& ex)
 730         {
 731                 LoggerE("Exception: " << ex.GetMessage());
 732         }
 733
 734
 735 }
 736 void SQLDataControlConsumer::handlePendingEvent(const EventSelectPtr& event)
 737 {
 738         WrtDeviceApis::Commons::EventRequestReceiver<EventSelect>::ManualAnswer(event);
 739         try {
 740                 CommonPendingEvent* userData = (CommonPendingEvent*)DataControlAsyncCallbackManagerSingleton::Instance().getRemainingSQLOperation();
 741
 742                 if (userData)
 743                 {
 744                         SendAppControlLaunchToProvider(userData);
 745                 }
 746         }
 747         catch (const WrtDeviceApis::Commons::Exception& ex)
 748         {
 749                 LoggerE("Exception: " << ex.GetMessage());
 750         }
 751
 752 }
 753
 754 void SQLDataControlConsumer::handlePendingEvent(const EventUpdatePtr& event)
 755 {
 756         WrtDeviceApis::Commons::EventRequestReceiver<EventUpdate>::ManualAnswer(event);
 757         try {
 758                 CommonPendingEvent* userData = (CommonPendingEvent*)DataControlAsyncCallbackManagerSingleton::Instance().getRemainingSQLOperation();
 759
 760                 if (userData)
 761                 {
 762                         SendAppControlLaunchToProvider(userData);
 763                 }
 764         }
 765         catch (const WrtDeviceApis::Commons::Exception& ex)
 766         {
 767                 LoggerE("Exception: " << ex.GetMessage());
 768         }
 769
 770 }
 771
 772
 773 void SQLDataControlConsumer::insertData(const EventInsertPtr& event)
 774 {
 775         WrtDeviceApis::Commons::EventRequestReceiver<EventInsert>::PostRequest(event);
 776 }
 777
 778 void SQLDataControlConsumer::deleteData(const EventDeletePtr& event)
 779 {
 780         WrtDeviceApis::Commons::EventRequestReceiver<EventDelete>::PostRequest(event);
 781 }
 782
 783 void SQLDataControlConsumer::selectData(const EventSelectPtr& event)
 784 {
 785         WrtDeviceApis::Commons::EventRequestReceiver<EventSelect>::PostRequest(event);
 786 }
 787
 788 void SQLDataControlConsumer::updateData(const EventUpdatePtr& event)
 789 {
 790         WrtDeviceApis::Commons::EventRequestReceiver<EventUpdate>::PostRequest(event);
 791 }
 792
 793 void SQLDataControlConsumer::createResultDir()
 794 {
 795     struct stat info;
 796     memset(&info, 0, sizeof(struct stat));
 797
 798     int status = lstat(DATACONTROL_PROTOCOL_DIR_TOP, &info);
 799
 800         if (status != 0 && errno == ENOENT)
 801         {
 802                 if (mkdir(DATACONTROL_PROTOCOL_DIR_TOP, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0)
 803                 {
 804                         LoggerD("make error");
 805                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "result dir could not be created.");
 806                 }
 807         }
 808
 809     status = lstat(DATACONTROL_PROTOCOL_DIR_MIDDLE, &info);
 810
 811         if (status != 0 && errno == ENOENT)
 812         {
 813                 if (mkdir(DATACONTROL_PROTOCOL_DIR_MIDDLE, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0)
 814                 {
 815                         LoggerD("make error");
 816                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "result dir could not be created.");
 817                 }
 818         }
 819
 820     status = lstat(DATACONTROL_PROTOCOL_DIR, &info);
 821
 822         // already exist
 823         if (status == 0)
 824         {
 825                 LoggerD("already exist");
 826         return;
 827     }
 828         else if (errno == ENOENT)
 829         {
 830                 if (mkdir(DATACONTROL_PROTOCOL_DIR, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0)
 831                 {
 832                         LoggerD("make error");
 833                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "result dir could not be created.");
 834                 }
 835                 return;
 836     }
 837     ThrowMsg(WrtDeviceApis::Commons::PlatformException, "result dir could be error during checking status");
 838 }
 839
 840 std::string SQLDataControlConsumer::convertIntToString(unsigned int data)
 841 {
 842         std::stringstream ssbuffer;
 843
 844         ssbuffer.str("");
 845         ssbuffer << data;
 846         return ssbuffer.str();
 847 }
 848
 849 void SQLDataControlConsumer::SendAppControlLaunchToProvider(void* event)
 850 {
 851         LoggerD("OK");
 852         bundle* passData = NULL;
 853         std::string dataId = getDataId();
 854         std::vector<std::string> queryItem;
 855         std::stringstream ssBuffer;
 856         std::string stringBuffer;
 857         CommonPendingEvent* pEvent = (CommonPendingEvent*)(event);
 858         std::string ipcFilename;
 859         std::string where;
 860         unsigned int reqId = 0;
 861         unsigned int columnSize = 0;
 862
 863         try
 864         {
 865                 passData = bundle_create();
 866
 867                 if (passData == NULL)
 868                 {
 869                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "ipc memory allocation fail");
 870                 }
 871
 872                 if (pEvent == NULL)
 873                 {
 874                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "event null");
 875                 }
 876
 877                 appsvc_set_operation(passData, APPSVC_OPERATION_DEFAULT);
 878                 appsvc_set_appid(passData, m_appId.c_str());
 879
 880                 bundle_add(passData, OSP_K_CALLER_TYPE, OSP_V_CALLER_TYPE_OSP);
 881                 bundle_add(passData, OSP_K_LAUNCH_TYPE, OSP_V_LAUNCH_TYPE_DATACONTROL);
 882                 bundle_add(passData, OSP_K_DATACONTROL_PROVIDER, m_providerId.c_str());
 883                 bundle_add(passData, OSP_K_DATACONTROL_PROTOCOL_VERSION, OSP_K_DATACONTROL_PROTOCOL_VERSION_VALUE); // version
 884                 bundle_add(passData, AUL_K_CALLER_APPID, m_currentAppId.c_str());
 885
 886                 if (dynamic_cast<EventInsertPendingEvent*>(pEvent) != NULL)
 887                 {
 888                         EventInsertPendingEvent* pendingInsertEvent = (EventInsertPendingEvent*)pEvent;
 889                         EventInsertPtr insertEvent = pendingInsertEvent->getEvent();
 890
 891                         reqId = insertEvent->getReqId();
 892                         columnSize = insertEvent->getColumnSize();
 893
 894                         stringBuffer = convertIntToString(reqId);
 895                         bundle_add(passData, OSP_K_REQUEST_ID, stringBuffer.c_str());
 896
 897                         ipcFilename     = generateFileName(reqId);
 898                         stringBuffer = convertIntToString(columnSize);
 899
 900                         queryItem.push_back(dataId);
 901                         queryItem.push_back(stringBuffer);
 902                         queryItem.push_back(ipcFilename);
 903
 904                         stringBuffer = convertIntToString(_DATACONTROL_REQUEST_TYPE_SQL_INSERT);
 905                         bundle_add(passData, OSP_K_DATACONTROL_REQUEST_TYPE, stringBuffer.c_str());
 906
 907                         addArrayToBundle(passData, queryItem);
 908                 }
 909                 else if (dynamic_cast<EventUpdatePendingEvent*>(pEvent) != NULL)
 910                 {
 911                         EventUpdatePendingEvent* pendingUpdateEvent = (EventUpdatePendingEvent*)pEvent;
 912                         EventUpdatePtr updateEvent = pendingUpdateEvent->getEvent();
 913
 914                         reqId = updateEvent->getReqId();
 915                         columnSize = updateEvent->getColumnSize();
 916                         where = updateEvent->getWhere();
 917
 918                         stringBuffer = convertIntToString(reqId);
 919                         bundle_add(passData, OSP_K_REQUEST_ID, stringBuffer.c_str());
 920
 921                         stringBuffer = convertIntToString(_DATACONTROL_REQUEST_TYPE_SQL_UPDATE);
 922                         bundle_add(passData, OSP_K_DATACONTROL_REQUEST_TYPE, stringBuffer.c_str());
 923
 924                         ipcFilename     = generateFileName(reqId);
 925                         stringBuffer = convertIntToString(columnSize);
 926
 927                         queryItem.push_back(dataId);
 928                         queryItem.push_back(stringBuffer);
 929                         queryItem.push_back(ipcFilename);
 930
 931                         if (where.size() == 0)  // where
 932                         {
 933                                 queryItem.push_back("NULL");
 934                         }
 935                         else
 936                         {
 937                                 queryItem.push_back(where);
 938                         }
 939
 940                         addArrayToBundle(passData, queryItem);
 941
 942                 }
 943                 else if (dynamic_cast<EventSelectPendingEvent*>(pEvent) != NULL)
 944                 {
 945                         EventSelectPendingEvent* pendingSelectEvent = (EventSelectPendingEvent*)pEvent;
 946                         EventSelectPtr selectEvent = pendingSelectEvent->getEvent();
 947
 948                         reqId = selectEvent->getReqId();
 949                         std::vector<std::string> columns = selectEvent->getColumns();
 950                         columnSize = columns.size();
 951                         where = selectEvent->getWhere();
 952                         std::string order = selectEvent->getOrder();
 953                         std::string page = selectEvent->getPage();
 954                         std::string numberPerPage = selectEvent->getNumerPerPage();
 955
 956                         stringBuffer = convertIntToString(reqId);
 957                         bundle_add(passData, OSP_K_REQUEST_ID, stringBuffer.c_str());
 958
 959                         stringBuffer = convertIntToString(_DATACONTROL_REQUEST_TYPE_SQL_QUERY);
 960                         bundle_add(passData, OSP_K_DATACONTROL_REQUEST_TYPE, stringBuffer.c_str());
 961
 962                         queryItem.push_back(dataId);
 963
 964                         if (columnSize == 0)
 965                         {
 966                                 queryItem.push_back("NULL");
 967                         }
 968                         else
 969                         {
 970                                 stringBuffer = convertIntToString(columnSize);
 971                                 queryItem.push_back(stringBuffer);
 972
 973                                 for (int index = 0; index < columnSize; index++)
 974                                 {
 975                                         queryItem.push_back(columns[index]);
 976                                 }
 977                         }
 978
 979                         if (where.size() == 0)
 980                         {
 981                                 queryItem.push_back("NULL");
 982                         }
 983                         else
 984                         {
 985                                 queryItem.push_back(where);
 986                         }
 987
 988                         if (order.size() == 0)
 989                         {
 990                                 queryItem.push_back("NULL");
 991                         }
 992                         else
 993                         {
 994                                 queryItem.push_back(order);
 995                         }
 996
 997                         if (page.size() == 0) // page
 998                         {
 999                                 queryItem.push_back("1");
1000                         }
1001                         else
1002                         {
1003                                 queryItem.push_back(page);
1004                         }
1005
1006                         if (numberPerPage.size() == 0) // numberOfPage
1007                         {
1008                                 queryItem.push_back("20");
1009                         }
1010                         else
1011                         {
1012                                 queryItem.push_back(numberPerPage);
1013                         }
1014
1015                         addArrayToBundle(passData, queryItem);
1016                 }
1017                 else if (dynamic_cast<EventDeletePendingEvent*>(pEvent) != NULL)
1018                 {
1019                         EventDeletePendingEvent* pendingDeleteEvent = (EventDeletePendingEvent*)pEvent;
1020                         EventDeletePtr deleteEvent = pendingDeleteEvent->getEvent();
1021                         reqId = deleteEvent->getReqId();
1022                         stringBuffer = convertIntToString(reqId);
1023                         bundle_add(passData, OSP_K_REQUEST_ID, stringBuffer.c_str());
1024
1025                         stringBuffer = convertIntToString(_DATACONTROL_REQUEST_TYPE_SQL_DELETE);
1026                         bundle_add(passData, OSP_K_DATACONTROL_REQUEST_TYPE, stringBuffer.c_str());
1027
1028                         queryItem.push_back(dataId); // dataid
1029                         where = deleteEvent->getWhere();
1030
1031                         if (where.size() == 0)  // where
1032                         {
1033                                 queryItem.push_back("NULL");
1034                         }
1035                         else
1036                         {
1037                                 queryItem.push_back(where);
1038                         }
1039
1040                         addArrayToBundle(passData, queryItem);
1041                 }
1042                 else
1043                 {
1044                         // never happen
1045                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "no type request type");
1046                 }
1047
1048                 int pid = appsvc_run_service(passData, reqId, sqldataControlCommonCallback, (void*)NULL);
1049
1050                 if (pid < 0)
1051                 {
1052                         ThrowMsg(WrtDeviceApis::Commons::AlreadyInUseException, "Launch Error");
1053                 }
1054
1055                 LoggerD("Launch OK : pid(" << pid << "), reqid : (" << reqId << ")");
1056         }
1057         catch (const WrtDeviceApis::Commons::Exception& ex)
1058         {
1059                 LoggerE("Exception: " << ex.GetMessage());
1060                 if (passData)
1061                 {
1062                         bundle_free(passData);
1063                         passData = NULL;
1064                 }
1065                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, ex.GetMessage());
1066
1067         }
1068
1069 }
1070
1071 void SQLDataControlConsumer::OnRequestReceived(const EventInsertPtr& event)
1072 {
1073         LoggerD("Enter");
1074
1075         try
1076         {
1077                 RowData* rowData = event->getRowData();
1078                 unsigned int reqId = event->getReqId();
1079                 std::string ipcFilename = generateFileName(reqId);
1080                 std::string reqIdStr = convertIntToString(reqId);
1081
1082                 if (checkReqIdUniqueness(reqId) == false)
1083                 {
1084                         ThrowMsg(WrtDeviceApis::Commons::AlreadyInUseException, "Duplicated requested id");
1085                 }
1086
1087                 if (rowData == NULL || rowData->m_Data.size() == 0)
1088                 {
1089                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "No insertion data");
1090                 }
1091
1092                 saveArrayToFile(ipcFilename, rowData);
1093                 delete rowData;
1094
1095                 EventInsertPendingEvent* pendingEvent = new EventInsertPendingEvent((void*)this, event);
1096
1097                 if (DataControlAsyncCallbackManagerSingleton::Instance().checkDoSQLOperation())
1098                 {
1099                         SendAppControlLaunchToProvider(pendingEvent);
1100                 }
1101                 event->switchToManualAnswer();
1102                 DataControlAsyncCallbackManagerSingleton::Instance().addSQLUserData(reqIdStr, (void*)pendingEvent);
1103
1104
1105         }
1106         catch (const WrtDeviceApis::Commons::Exception& ex)
1107         {
1108                 event->setExceptionCode(ex.getCode());
1109                 event->setErrorMsg(ex.GetMessage());
1110                 LoggerE("Exception: " << ex.GetMessage());
1111
1112
1113         }
1114 }
1115 void SQLDataControlConsumer::OnRequestReceived(const EventDeletePtr& event)
1116 {
1117         LoggerD("Enter");
1118         bundle* passData = NULL;
1119
1120         try
1121         {
1122                 unsigned int reqId = event->getReqId();
1123                 std::string reqIdStr = convertIntToString(reqId);
1124
1125                 if (checkReqIdUniqueness(reqId) == false)
1126                 {
1127                         ThrowMsg(WrtDeviceApis::Commons::AlreadyInUseException, "Duplicated requested id");
1128                 }
1129
1130                 EventDeletePendingEvent* pendingEvent = new EventDeletePendingEvent(this, event);
1131
1132                 if (DataControlAsyncCallbackManagerSingleton::Instance().checkDoSQLOperation())
1133                 {
1134                         SendAppControlLaunchToProvider(pendingEvent);
1135                 }
1136                 event->switchToManualAnswer();
1137                 DataControlAsyncCallbackManagerSingleton::Instance().addSQLUserData(reqIdStr, (void*)pendingEvent);
1138         }
1139
1140         catch (const WrtDeviceApis::Commons::Exception& ex)
1141         {
1142                 LoggerE("Exception: " << ex.GetMessage());
1143                 event->setExceptionCode(ex.getCode());
1144                 event->setErrorMsg(ex.GetMessage());
1145         }
1146
1147         if (passData)
1148         {
1149                 bundle_free(passData);
1150                 passData = NULL;
1151         }
1152
1153 }
1154 void SQLDataControlConsumer::OnRequestReceived(const EventSelectPtr& event)
1155 {
1156         try
1157         {
1158                 unsigned int reqId = event->getReqId();
1159                 std::string reqIdStr = convertIntToString(reqId);
1160
1161                 if (checkReqIdUniqueness(reqId) == false)
1162                 {
1163                         ThrowMsg(WrtDeviceApis::Commons::AlreadyInUseException, "Duplicated requested id");
1164                 }
1165
1166                 EventSelectPendingEvent* pendingEvent = new EventSelectPendingEvent(this, event);
1167
1168                 if (DataControlAsyncCallbackManagerSingleton::Instance().checkDoSQLOperation())
1169                 {
1170                         SendAppControlLaunchToProvider(pendingEvent);
1171                 }
1172
1173                 event->switchToManualAnswer();
1174                 DataControlAsyncCallbackManagerSingleton::Instance().addSQLUserData(reqIdStr, (void*)pendingEvent);
1175         }
1176         catch (const WrtDeviceApis::Commons::Exception& ex)
1177         {
1178                 LoggerE("Exception: " << ex.GetMessage());
1179                 event->setExceptionCode(ex.getCode());
1180                 event->setErrorMsg(ex.GetMessage());
1181         }
1182
1183 }
1184
1185 void SQLDataControlConsumer::OnRequestReceived(const EventUpdatePtr& event)
1186 {
1187         LoggerD("Enter");
1188
1189         try
1190         {
1191                 unsigned int reqId = event->getReqId();
1192                 RowData* rowData = event->getRowData();
1193                 std::string ipcFilename = generateFileName(reqId);
1194                 std::stringstream ssReqId;
1195                 ssReqId << reqId;
1196
1197                 if (checkReqIdUniqueness(reqId) == false)
1198                 {
1199                         ThrowMsg(WrtDeviceApis::Commons::AlreadyInUseException, "Duplicated requested id");
1200                 }
1201
1202                 if (rowData == NULL || rowData->m_Data.size() == 0)
1203                 {\r
1204                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "No update data");
1205                 }
1206
1207                 saveArrayToFile(ipcFilename, rowData);
1208                 delete rowData;
1209
1210                 EventUpdatePendingEvent* pendingEvent = new EventUpdatePendingEvent(this, event);
1211
1212                 if (DataControlAsyncCallbackManagerSingleton::Instance().checkDoSQLOperation())
1213                 {
1214                         SendAppControlLaunchToProvider(pendingEvent);
1215                 }
1216                 event->switchToManualAnswer();
1217                 DataControlAsyncCallbackManagerSingleton::Instance().addSQLUserData(ssReqId.str(), (void*)pendingEvent);
1218
1219         }
1220         catch (const WrtDeviceApis::Commons::Exception& ex)
1221         {
1222                 LoggerE("Exception: " << ex.GetMessage());
1223                 event->setExceptionCode(ex.getCode());
1224                 event->setErrorMsg(ex.GetMessage());
1225         }
1226
1227 }
1228 }
1229 }
1230
1231