server/cal_server_ipc.c

   1 /*
   2  * Calendar Service
   3  *
   4  * Copyright (c) 2012 - 2015 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 <stdlib.h>
  21 #include <malloc.h>
  22 #include <glib.h>
  23 #include <pims-ipc-data.h>
  24
  25 #include "calendar.h"
  26 #include "cal_typedef.h"
  27 #include "cal_internal.h"
  28 #include "cal_db_util.h"
  29 #include "cal_ipc_marshal.h"
  30 #include "cal_server_ipc.h"
  31 #include "cal_access_control.h"
  32 #include "cal_handle.h"
  33 #include "cal_server_service.h"
  34 #include "cal_db.h"
  35 #include "cal_server.h"
  36 #include "cal_ondemand.h"
  37
  38
  39 static void _cal_server_ipc_return(pims_ipc_data_h *outdata, int ret)
  40 {
  41         RET_IF(NULL == outdata);
  42
  43         *outdata = pims_ipc_data_create(0);
  44         RETM_IF(NULL == *outdata, "pims_ipc_data_create() Fail");
  45
  46         if (0 != pims_ipc_data_put(*outdata, (void *)&ret, sizeof(int))) {
  47                 ERR("pims_ipc_data_put() Fail");
  48                 pims_ipc_data_destroy(*outdata);
  49                 *outdata = NULL;
  50         }
  51 }
  52
  53 void cal_server_ipc_connect(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
  54 {
  55         int ret = CALENDAR_ERROR_NONE;
  56
  57         if (NULL == indata) {
  58                 ERR("No indata");
  59                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
  60                 _cal_server_ipc_return(outdata, ret);
  61                 return;
  62         }
  63
  64         calendar_h handle = NULL;
  65         ret = cal_ipc_unmarshal_handle(indata, &handle);
  66         if (CALENDAR_ERROR_NONE != ret) {
  67                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
  68                 _cal_server_ipc_return(outdata, ret);
  69                 return;
  70         }
  71
  72         ret = cal_connect();
  73         if (CALENDAR_ERROR_NONE == ret) {
  74                 char *smack_label = NULL;
  75                 if (0 != pims_ipc_svc_get_smack_label(ipc, &smack_label))
  76                         ERR("pims_ipc_svc_get_smack_label() Fail");
  77                 cal_access_control_set_client_info(ipc, smack_label);
  78         }
  79         _cal_server_ipc_return(outdata, ret);
  80         cal_handle_destroy(handle);
  81 }
  82
  83 void cal_server_ipc_disconnect(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
  84 {
  85         int ret = CALENDAR_ERROR_NONE;
  86
  87         if (NULL == indata) {
  88                 ERR("No indata");
  89                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
  90                 _cal_server_ipc_return(outdata, ret);
  91                 return;
  92         }
  93
  94         calendar_h handle = NULL;
  95         ret = cal_ipc_unmarshal_handle(indata, &handle);
  96         if (CALENDAR_ERROR_NONE != ret) {
  97                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
  98                 _cal_server_ipc_return(outdata, ret);
  99                 return;
 100         }
 101
 102         ret = cal_disconnect();
 103         _cal_server_ipc_return(outdata, ret);
 104         cal_handle_destroy(handle);
 105 }
 106
 107 void cal_server_ipc_check_permission(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 108 {
 109         int ret = CALENDAR_ERROR_NONE;
 110
 111         if (NULL == indata) {
 112                 ERR("No indata");
 113                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 114                 _cal_server_ipc_return(outdata, ret);
 115                 return;
 116         }
 117
 118         int permission = 0;
 119         ret = cal_ipc_unmarshal_int(indata, &permission);
 120         if (CALENDAR_ERROR_NONE != ret) {
 121                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 122                 _cal_server_ipc_return(outdata, ret);
 123                 return;
 124         }
 125
 126         bool result = cal_access_control_have_permission(ipc, permission);
 127         _cal_server_ipc_return(outdata, ret);
 128
 129         if (0 != pims_ipc_data_put(*outdata, (void *)&result, sizeof(bool))) {
 130                 ERR("pims_ipc_data_put() Fail");
 131                 pims_ipc_data_destroy(*outdata);
 132                 *outdata = NULL;
 133                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 134                 _cal_server_ipc_return(outdata, ret);
 135         }
 136 }
 137
 138 void cal_server_ipc_db_insert_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 139 {
 140         int ret = CALENDAR_ERROR_NONE;
 141
 142         if (NULL == indata) {
 143                 ERR("No indata");
 144                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 145                 _cal_server_ipc_return(outdata, ret);
 146                 return;
 147         }
 148
 149         calendar_h handle = NULL;
 150         ret = cal_ipc_unmarshal_handle(indata, &handle);
 151         if (CALENDAR_ERROR_NONE != ret) {
 152                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 153                 _cal_server_ipc_return(outdata, ret);
 154                 return;
 155         }
 156
 157         calendar_record_h record = NULL;
 158         ret = cal_ipc_unmarshal_record(indata, &record);
 159         if (CALENDAR_ERROR_NONE != ret) {
 160                 ERR("cal_ipc_unmarshal_record() Fail(%d)", ret);
 161                 _cal_server_ipc_return(outdata, ret);
 162                 cal_handle_destroy(handle);
 163                 return;
 164         }
 165
 166         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
 167                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 168                 _cal_server_ipc_return(outdata, ret);
 169                 cal_handle_destroy(handle);
 170                 return;
 171         }
 172
 173         int id = 0;
 174         ret = cal_db_insert_record(record, &id);
 175         _cal_server_ipc_return(outdata, ret);
 176
 177         int transaction_ver = 0;
 178         transaction_ver = cal_db_util_get_transaction_ver();
 179         ret = cal_ipc_marshal_int(transaction_ver, *outdata);
 180         if (CALENDAR_ERROR_NONE != ret) {
 181                 ERR("cal_ipc_marshal_int() Fail(%d)", ret);
 182                 pims_ipc_data_destroy(*outdata);
 183                 *outdata = NULL;
 184                 _cal_server_ipc_return(outdata, ret);
 185                 calendar_record_destroy(record, true);
 186                 cal_handle_destroy(handle);
 187                 return;
 188         }
 189
 190         ret = cal_ipc_marshal_int(id, *outdata);
 191         if (CALENDAR_ERROR_NONE != ret) {
 192                 ERR("cal_ipc_marshal_int() Fail(%d)", ret);
 193                 pims_ipc_data_destroy(*outdata);
 194                 *outdata = NULL;
 195                 _cal_server_ipc_return(outdata, ret);
 196         }
 197
 198         calendar_record_destroy(record, true);
 199         cal_handle_destroy(handle);
 200 }
 201
 202 void cal_server_ipc_db_get_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 203 {
 204         int ret = CALENDAR_ERROR_NONE;
 205
 206         if (NULL == indata) {
 207                 ERR("No indata");
 208                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 209                 _cal_server_ipc_return(outdata, ret);
 210                 return;
 211         }
 212
 213         calendar_h handle = NULL;
 214         ret = cal_ipc_unmarshal_handle(indata, &handle);
 215         if (CALENDAR_ERROR_NONE != ret) {
 216                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 217                 _cal_server_ipc_return(outdata, ret);
 218                 return;
 219         }
 220
 221         char* view_uri = NULL;
 222         ret = cal_ipc_unmarshal_char(indata, &view_uri);
 223         if (CALENDAR_ERROR_NONE != ret) {
 224                 ERR("cal_ipc_unmarshal_char() Fail(%d)", ret);
 225                 _cal_server_ipc_return(outdata, ret);
 226                 free(view_uri);
 227                 cal_handle_destroy(handle);
 228                 return;
 229         }
 230
 231         int id = 0;
 232         ret = cal_ipc_unmarshal_int(indata, &id);
 233         if (CALENDAR_ERROR_NONE != ret) {
 234                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 235                 _cal_server_ipc_return(outdata, ret);
 236                 free(view_uri);
 237                 cal_handle_destroy(handle);
 238                 return;
 239         }
 240
 241         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_READ)) {
 242                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 243                 _cal_server_ipc_return(outdata, ret);
 244                 free(view_uri);
 245                 cal_handle_destroy(handle);
 246                 return;
 247         }
 248
 249         calendar_record_h record = NULL;
 250         ret = cal_db_get_record(view_uri, id, &record);
 251         _cal_server_ipc_return(outdata, ret);
 252
 253         if (CALENDAR_ERROR_NONE == ret) {
 254                 ret = cal_ipc_marshal_record(record, *outdata);
 255                 if (CALENDAR_ERROR_NONE != ret) {
 256                         ERR("cal_ipc_marshal_record() Fail(%d)", ret);
 257                         pims_ipc_data_destroy(*outdata);
 258                         *outdata = NULL;
 259                         _cal_server_ipc_return(outdata, ret);
 260                 }
 261         }
 262
 263         calendar_record_destroy(record, true);
 264         free(view_uri);
 265         cal_handle_destroy(handle);
 266 }
 267
 268 void cal_server_ipc_db_update_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 269 {
 270         int ret = CALENDAR_ERROR_NONE;
 271
 272         if (NULL == indata) {
 273                 ERR("No indata");
 274                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 275                 _cal_server_ipc_return(outdata, ret);
 276                 return;
 277         }
 278
 279         calendar_h handle = NULL;
 280         ret = cal_ipc_unmarshal_handle(indata, &handle);
 281         if (CALENDAR_ERROR_NONE != ret) {
 282                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 283                 _cal_server_ipc_return(outdata, ret);
 284                 return;
 285         }
 286
 287         calendar_record_h record = NULL;
 288         ret = cal_ipc_unmarshal_record(indata, &record);
 289         if (CALENDAR_ERROR_NONE != ret) {
 290                 ERR("cal_ipc_unmarshal_record() Fail(%d)", ret);
 291                 _cal_server_ipc_return(outdata, ret);
 292                 cal_handle_destroy(handle);
 293                 return;
 294         }
 295
 296         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
 297                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 298                 _cal_server_ipc_return(outdata, ret);
 299                 cal_handle_destroy(handle);
 300                 return;
 301         }
 302
 303         ret = cal_db_update_record(record);
 304         _cal_server_ipc_return(outdata, ret);
 305
 306         if (CALENDAR_ERROR_NONE == ret) {
 307                 int transaction_ver = 0;
 308                 transaction_ver = cal_db_util_get_transaction_ver();
 309                 ret = cal_ipc_marshal_int(transaction_ver, *outdata);
 310                 if (CALENDAR_ERROR_NONE != ret) {
 311                         ERR("cal_ipc_marshal_int() Fail(%d)", ret);
 312                         pims_ipc_data_destroy(*outdata);
 313                         *outdata = NULL;
 314                         _cal_server_ipc_return(outdata, ret);
 315                 }
 316         }
 317
 318         calendar_record_destroy(record, true);
 319         cal_handle_destroy(handle);
 320 }
 321
 322 void cal_server_ipc_db_delete_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 323 {
 324         int ret = CALENDAR_ERROR_NONE;
 325
 326         if (NULL == indata) {
 327                 ERR("No indata");
 328                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 329                 _cal_server_ipc_return(outdata, ret);
 330                 return;
 331         }
 332
 333         calendar_h handle = NULL;
 334         ret = cal_ipc_unmarshal_handle(indata, &handle);
 335         if (CALENDAR_ERROR_NONE != ret) {
 336                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 337                 _cal_server_ipc_return(outdata, ret);
 338                 return;
 339         }
 340
 341         char* view_uri = NULL;
 342         ret = cal_ipc_unmarshal_char(indata, &view_uri);
 343         if (CALENDAR_ERROR_NONE != ret) {
 344                 ERR("cal_ipc_unmarshal_char() Fail(%d)", ret);
 345                 _cal_server_ipc_return(outdata, ret);
 346                 cal_handle_destroy(handle);
 347                 return;
 348         }
 349
 350         int id = 0;
 351         ret = cal_ipc_unmarshal_int(indata, &id);
 352         if (CALENDAR_ERROR_NONE != ret) {
 353                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 354                 _cal_server_ipc_return(outdata, ret);
 355                 free(view_uri);
 356                 cal_handle_destroy(handle);
 357                 return;
 358         }
 359
 360         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
 361                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 362                 _cal_server_ipc_return(outdata, ret);
 363                 free(view_uri);
 364                 cal_handle_destroy(handle);
 365                 return;
 366         }
 367
 368         ret = cal_db_delete_record(view_uri,id);
 369         _cal_server_ipc_return(outdata, ret);
 370
 371         if (CALENDAR_ERROR_NONE == ret) {
 372                 int transaction_ver = 0;
 373                 transaction_ver = cal_db_util_get_transaction_ver();
 374                 ret = cal_ipc_marshal_int(transaction_ver, *outdata);
 375                 if (CALENDAR_ERROR_NONE != ret) {
 376                         ERR("cal_ipc_marshal_int() Fail(%d)", ret);
 377                         pims_ipc_data_destroy(*outdata);
 378                         *outdata = NULL;
 379                         _cal_server_ipc_return(outdata, ret);
 380                 }
 381         }
 382
 383         free(view_uri);
 384         cal_handle_destroy(handle);
 385 }
 386
 387 void cal_server_ipc_db_get_all_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 388 {
 389         int ret = CALENDAR_ERROR_NONE;
 390
 391         if (NULL == indata) {
 392                 ERR("No indata");
 393                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 394                 _cal_server_ipc_return(outdata, ret);
 395                 return;
 396         }
 397
 398         calendar_h handle = NULL;
 399         ret = cal_ipc_unmarshal_handle(indata, &handle);
 400         if (CALENDAR_ERROR_NONE != ret) {
 401                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 402                 _cal_server_ipc_return(outdata, ret);
 403                 return;
 404         }
 405
 406         char* view_uri = NULL;
 407         ret = cal_ipc_unmarshal_char(indata, &view_uri);
 408         if (CALENDAR_ERROR_NONE != ret) {
 409                 ERR("cal_ipc_unmarshal_char() Fail(%d)", ret);
 410                 _cal_server_ipc_return(outdata, ret);
 411                 cal_handle_destroy(handle);
 412                 return;
 413         }
 414
 415         int offset = 0;
 416         ret = cal_ipc_unmarshal_int(indata, &offset);
 417         if (CALENDAR_ERROR_NONE != ret) {
 418                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 419                 _cal_server_ipc_return(outdata, ret);
 420                 free(view_uri);
 421                 cal_handle_destroy(handle);
 422                 return;
 423         }
 424
 425         int limit = 0;
 426         ret = cal_ipc_unmarshal_int(indata, &limit);
 427         if (CALENDAR_ERROR_NONE != ret) {
 428                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 429                 _cal_server_ipc_return(outdata, ret);
 430                 free(view_uri);
 431                 cal_handle_destroy(handle);
 432                 return;
 433         }
 434
 435         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_READ)) {
 436                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 437                 _cal_server_ipc_return(outdata, ret);
 438                 free(view_uri);
 439                 cal_handle_destroy(handle);
 440                 return;
 441         }
 442
 443         calendar_list_h list = NULL;
 444         ret = cal_db_get_all_records(view_uri, offset, limit, &list);
 445         _cal_server_ipc_return(outdata, ret);
 446
 447         if (CALENDAR_ERROR_NONE == ret) {
 448                 ret = cal_ipc_marshal_list(list, *outdata);
 449                 if (CALENDAR_ERROR_NONE != ret) {
 450                         ERR("cal_ipc_marshal_list() Fail(%d)", ret);
 451                         pims_ipc_data_destroy(*outdata);
 452                         *outdata = NULL;
 453                         _cal_server_ipc_return(outdata, ret);
 454                 }
 455         }
 456
 457         calendar_list_destroy(list, true);
 458         free(view_uri);
 459         cal_handle_destroy(handle);
 460 }
 461
 462 void cal_server_ipc_db_get_records_with_query(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 463 {
 464         int ret = CALENDAR_ERROR_NONE;
 465
 466         if (NULL == indata) {
 467                 ERR("No indata");
 468                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 469                 _cal_server_ipc_return(outdata, ret);
 470                 return;
 471         }
 472
 473         calendar_h handle = NULL;
 474         ret = cal_ipc_unmarshal_handle(indata, &handle);
 475         if (CALENDAR_ERROR_NONE != ret) {
 476                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 477                 _cal_server_ipc_return(outdata, ret);
 478                 return;
 479         }
 480
 481         calendar_query_h query = NULL;
 482         ret = cal_ipc_unmarshal_query(indata, &query);
 483         if (CALENDAR_ERROR_NONE != ret) {
 484                 ERR("cal_ipc_unmarshal_query() Fail(%d)", ret);
 485                 _cal_server_ipc_return(outdata, ret);
 486                 cal_handle_destroy(handle);
 487                 return;
 488         }
 489
 490         int offset = 0;
 491         ret = cal_ipc_unmarshal_int(indata, &offset);
 492         if (CALENDAR_ERROR_NONE != ret) {
 493                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 494                 _cal_server_ipc_return(outdata, ret);
 495                 calendar_query_destroy(query);
 496                 cal_handle_destroy(handle);
 497                 return;
 498         }
 499
 500         int limit = 0;
 501         ret = cal_ipc_unmarshal_int(indata, &limit);
 502         if (CALENDAR_ERROR_NONE != ret) {
 503                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 504                 _cal_server_ipc_return(outdata, ret);
 505                 calendar_query_destroy(query);
 506                 cal_handle_destroy(handle);
 507                 return;
 508         }
 509
 510         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_READ)) {
 511                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 512                 _cal_server_ipc_return(outdata, ret);
 513                 calendar_query_destroy(query);
 514                 cal_handle_destroy(handle);
 515                 return;
 516         }
 517
 518         calendar_list_h list = NULL;
 519         ret = cal_db_get_records_with_query(query, offset, limit, &list);
 520         _cal_server_ipc_return(outdata, ret);
 521
 522         if (CALENDAR_ERROR_NONE == ret) {
 523                 ret = cal_ipc_marshal_list(list, *outdata);
 524                 if (CALENDAR_ERROR_NONE != ret) {
 525                         ERR("cal_ipc_marshal_list() Fail(%d)", ret);
 526                         pims_ipc_data_destroy(*outdata);
 527                         *outdata = NULL;
 528                         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 529                         _cal_server_ipc_return(outdata, ret);
 530                 }
 531         }
 532
 533         calendar_list_destroy(list, true);
 534         calendar_query_destroy(query);
 535         cal_handle_destroy(handle);
 536 }
 537
 538 void cal_server_ipc_db_clean_after_sync(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 539 {
 540         int ret = CALENDAR_ERROR_NONE;
 541
 542         if (NULL == indata) {
 543                 ERR("No indata");
 544                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 545                 _cal_server_ipc_return(outdata, ret);
 546                 return;
 547         }
 548
 549         calendar_h handle = NULL;
 550         ret = cal_ipc_unmarshal_handle(indata, &handle);
 551         if (CALENDAR_ERROR_NONE != ret) {
 552                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 553                 _cal_server_ipc_return(outdata, ret);
 554                 return;
 555         }
 556
 557         int calendar_book_id = 0;
 558         ret = cal_ipc_unmarshal_int(indata,&calendar_book_id);
 559         if (CALENDAR_ERROR_NONE != ret) {
 560                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 561                 _cal_server_ipc_return(outdata, ret);
 562                 cal_handle_destroy(handle);
 563                 return;
 564         }
 565
 566         int calendar_db_version = 0;
 567         ret = cal_ipc_unmarshal_int(indata, &calendar_db_version);
 568         if (CALENDAR_ERROR_NONE != ret) {
 569                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 570                 _cal_server_ipc_return(outdata, ret);
 571                 cal_handle_destroy(handle);
 572                 return;
 573         }
 574
 575         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
 576                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 577                 _cal_server_ipc_return(outdata, ret);
 578                 cal_handle_destroy(handle);
 579                 return;
 580         }
 581
 582         ret = cal_db_clean_after_sync(calendar_book_id, calendar_db_version);
 583         _cal_server_ipc_return(outdata, ret);
 584         cal_handle_destroy(handle);
 585 }
 586
 587 void cal_server_ipc_db_get_count(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 588 {
 589         int ret = CALENDAR_ERROR_NONE;
 590
 591         if (NULL == indata) {
 592                 ERR("No indata");
 593                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 594                 _cal_server_ipc_return(outdata, ret);
 595                 return;
 596         }
 597
 598         calendar_h handle = NULL;
 599         ret = cal_ipc_unmarshal_handle(indata, &handle);
 600         if (CALENDAR_ERROR_NONE != ret) {
 601                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 602                 _cal_server_ipc_return(outdata, ret);
 603                 return;
 604         }
 605
 606         char *view_uri = NULL;
 607         ret = cal_ipc_unmarshal_char(indata, &view_uri);
 608         if (CALENDAR_ERROR_NONE != ret) {
 609                 ERR("cal_ipc_unmarshal_char() Fail(%d)", ret);
 610                 _cal_server_ipc_return(outdata, ret);
 611                 cal_handle_destroy(handle);
 612                 return;
 613         }
 614
 615         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_READ)) {
 616                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 617                 _cal_server_ipc_return(outdata, ret);
 618                 cal_handle_destroy(handle);
 619                 return;
 620         }
 621
 622         int count = 0;
 623         ret = cal_db_get_count(view_uri, &count);
 624         _cal_server_ipc_return(outdata, ret);
 625
 626         if (CALENDAR_ERROR_NONE == ret) {
 627                 ret = cal_ipc_marshal_int(count, *outdata);
 628                 if (CALENDAR_ERROR_NONE != ret) {
 629                         ERR("cal_ipc_marshal_int() Fail(%d)", ret);
 630                         pims_ipc_data_destroy(*outdata);
 631                         *outdata = NULL;
 632                         _cal_server_ipc_return(outdata, ret);
 633                 }
 634         }
 635
 636         free(view_uri);
 637         cal_handle_destroy(handle);
 638 }
 639
 640 void cal_server_ipc_db_get_count_with_query(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 641 {
 642         int ret = CALENDAR_ERROR_NONE;
 643
 644         if (NULL == indata) {
 645                 ERR("No indata");
 646                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 647                 _cal_server_ipc_return(outdata, ret);
 648                 return;
 649         }
 650
 651         calendar_h handle = NULL;
 652         ret = cal_ipc_unmarshal_handle(indata, &handle);
 653         if (CALENDAR_ERROR_NONE != ret) {
 654                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 655                 _cal_server_ipc_return(outdata, ret);
 656                 return;
 657         }
 658
 659         calendar_query_h query = NULL;
 660         ret = cal_ipc_unmarshal_query(indata,&query);
 661         if (CALENDAR_ERROR_NONE != ret) {
 662                 ERR("cal_ipc_unmarshal_query() Fail(%d)", ret);
 663                 _cal_server_ipc_return(outdata, ret);
 664                 cal_handle_destroy(handle);
 665                 return;
 666         }
 667
 668         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_READ)) {
 669                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 670                 _cal_server_ipc_return(outdata, ret);
 671                 cal_handle_destroy(handle);
 672                 return;
 673         }
 674
 675         int count = 0;
 676         ret = cal_db_get_count_with_query(query, &count);
 677         _cal_server_ipc_return(outdata, ret);
 678
 679         if (CALENDAR_ERROR_NONE == ret) {
 680                 ret = cal_ipc_marshal_int(count, *outdata);
 681                 if (CALENDAR_ERROR_NONE != ret) {
 682                         ERR("cal_ipc_marshal_int() Fail(%d)", ret);
 683                         pims_ipc_data_destroy(*outdata);
 684                         *outdata = NULL;
 685                         _cal_server_ipc_return(outdata, ret);
 686                 }
 687         }
 688
 689         calendar_query_destroy(query);
 690         cal_handle_destroy(handle);
 691 }
 692
 693 void cal_server_ipc_db_insert_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 694 {
 695         int ret = CALENDAR_ERROR_NONE;
 696
 697         if (NULL == indata) {
 698                 ERR("No indata");
 699                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 700                 _cal_server_ipc_return(outdata, ret);
 701                 return;
 702         }
 703
 704         calendar_h handle = NULL;
 705         ret = cal_ipc_unmarshal_handle(indata, &handle);
 706         if (CALENDAR_ERROR_NONE != ret) {
 707                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 708                 _cal_server_ipc_return(outdata, ret);
 709                 return;
 710         }
 711
 712         calendar_list_h list = NULL;
 713         ret = cal_ipc_unmarshal_list(indata, &list);
 714         if (CALENDAR_ERROR_NONE != ret) {
 715                 ERR("cal_ipc_unmarshal_list() Fail(%d)", ret);
 716                 _cal_server_ipc_return(outdata, ret);
 717                 cal_handle_destroy(handle);
 718                 return;
 719         }
 720
 721         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
 722                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 723                 _cal_server_ipc_return(outdata, ret);
 724                 cal_handle_destroy(handle);
 725                 return;
 726         }
 727
 728         int *ids = NULL;
 729         int id_count = 0;
 730         ret = cal_db_insert_records(list, &ids, &id_count);
 731         _cal_server_ipc_return(outdata, ret);
 732
 733         if (CALENDAR_ERROR_NONE == ret) {
 734                 int transaction_ver = 0;
 735                 transaction_ver = cal_db_util_get_transaction_ver();
 736                 ret = cal_ipc_marshal_int(transaction_ver, *outdata);
 737                 if (CALENDAR_ERROR_NONE != ret) {
 738                         ERR("cal_ipc_marshal_int() Fail(%d)", ret);
 739                         pims_ipc_data_destroy(*outdata);
 740                         *outdata = NULL;
 741                         _cal_server_ipc_return(outdata, ret);
 742                         free(ids);
 743                         calendar_list_destroy(list, true);
 744                         cal_handle_destroy(handle);
 745                         return;
 746                 }
 747                 /*
 748                  * marshal : id_count+[ids]*id_count
 749                  * id_count
 750                  */
 751                 if (pims_ipc_data_put(*outdata, (void*)&id_count, sizeof(int)) != 0) {
 752                         ERR("pims_ipc_data_put() Fail");
 753                         pims_ipc_data_destroy(*outdata);
 754                         *outdata = NULL;
 755                         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 756                         _cal_server_ipc_return(outdata, ret);
 757                         free(ids);
 758                         calendar_list_destroy(list, true);
 759                         cal_handle_destroy(handle);
 760                         return;
 761                 }
 762
 763                 /* marshal ids */
 764                 int i=0;
 765                 for(i = 0; i < id_count; i++) {
 766                         if (pims_ipc_data_put(*outdata, (void*)&ids[i], sizeof(int)) != 0) {
 767                                 ERR("pims_ipc_data_put() Fail");
 768                                 pims_ipc_data_destroy(*outdata);
 769                                 *outdata = NULL;
 770                                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 771                                 _cal_server_ipc_return(outdata, ret);
 772                                 free(ids);
 773                                 calendar_list_destroy(list, true);
 774                                 cal_handle_destroy(handle);
 775                                 return;
 776                         }
 777                 }
 778         }
 779
 780         free(ids);
 781         calendar_list_destroy(list, true);
 782         cal_handle_destroy(handle);
 783 }
 784
 785 void cal_server_ipc_db_update_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 786 {
 787         int ret = CALENDAR_ERROR_NONE;
 788
 789         if (NULL == indata) {
 790                 ERR("No indata");
 791                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 792                 _cal_server_ipc_return(outdata, ret);
 793                 return;
 794         }
 795
 796         calendar_h handle = NULL;
 797         ret = cal_ipc_unmarshal_handle(indata, &handle);
 798         if (CALENDAR_ERROR_NONE != ret) {
 799                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 800                 _cal_server_ipc_return(outdata, ret);
 801                 return;
 802         }
 803
 804         calendar_list_h list = NULL;
 805         ret = cal_ipc_unmarshal_list(indata, &list);
 806         if (CALENDAR_ERROR_NONE != ret) {
 807                 ERR("cal_ipc_unmarshal_list() Fail(%d)", ret);
 808                 _cal_server_ipc_return(outdata, ret);
 809                 cal_handle_destroy(handle);
 810                 return;
 811         }
 812
 813         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
 814                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 815                 _cal_server_ipc_return(outdata, ret);
 816                 cal_handle_destroy(handle);
 817                 return;
 818         }
 819
 820         ret = cal_db_update_records(list);
 821         _cal_server_ipc_return(outdata, ret);
 822
 823         if (CALENDAR_ERROR_NONE == ret) {
 824                 int transaction_ver = 0;
 825                 transaction_ver = cal_db_util_get_transaction_ver();
 826                 ret = cal_ipc_marshal_int(transaction_ver, *outdata);
 827                 if (CALENDAR_ERROR_NONE != ret) {
 828                         ERR("cal_ipc_marshal_int() Fail(%d)", ret);
 829                         pims_ipc_data_destroy(*outdata);
 830                         *outdata = NULL;
 831                         _cal_server_ipc_return(outdata, ret);
 832                 }
 833         }
 834
 835         calendar_list_destroy(list,true);
 836         cal_handle_destroy(handle);
 837 }
 838
 839 void cal_server_ipc_db_delete_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 840 {
 841         int ret = CALENDAR_ERROR_NONE;
 842
 843         if (NULL == indata) {
 844                 ERR("No indata");
 845                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 846                 _cal_server_ipc_return(outdata, ret);
 847                 return;
 848         }
 849
 850         calendar_h handle = NULL;
 851         ret = cal_ipc_unmarshal_handle(indata, &handle);
 852         if (CALENDAR_ERROR_NONE != ret) {
 853                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 854                 _cal_server_ipc_return(outdata, ret);
 855                 return;
 856         }
 857
 858         char *view_uri = NULL;
 859         ret = cal_ipc_unmarshal_char(indata, &view_uri);
 860         if (CALENDAR_ERROR_NONE != ret) {
 861                 ERR("cal_ipc_unmarshal_char() Fail(%d)", ret);
 862                 _cal_server_ipc_return(outdata, ret);
 863                 cal_handle_destroy(handle);
 864                 return;
 865         }
 866
 867         int count = 0;
 868         ret = cal_ipc_unmarshal_int(indata, &count);
 869         if (CALENDAR_ERROR_NONE != ret) {
 870                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 871                 _cal_server_ipc_return(outdata, ret);
 872                 g_free(view_uri);
 873                 cal_handle_destroy(handle);
 874                 return;
 875         }
 876
 877         if (count <= 0) {
 878                 ERR("count(%d)", count);
 879                 ret = CALENDAR_ERROR_NO_DATA;
 880                 _cal_server_ipc_return(outdata, ret);
 881                 g_free(view_uri);
 882                 cal_handle_destroy(handle);
 883                 return;
 884         }
 885
 886         int *ids = NULL;
 887         ids = (int*)calloc(count, sizeof(int));
 888         if (NULL == ids) {
 889                 ERR("calloc() Fail");
 890                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 891                 _cal_server_ipc_return(outdata, ret);
 892                 free(view_uri);
 893                 cal_handle_destroy(handle);
 894                 return;
 895         }
 896
 897         int i = 0;
 898         for(i = 0; i < count; i++) {
 899                 ret = cal_ipc_unmarshal_int(indata, &ids[i]);
 900                 if (CALENDAR_ERROR_NONE != ret) {
 901                         ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 902                         ret = CALENDAR_ERROR_IPC;
 903                         _cal_server_ipc_return(outdata, ret);
 904                         free(ids);
 905                         free(view_uri);
 906                         cal_handle_destroy(handle);
 907                         return;
 908                 }
 909         }
 910
 911         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
 912                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 913                 _cal_server_ipc_return(outdata, ret);
 914                 free(ids);
 915                 free(view_uri);
 916                 cal_handle_destroy(handle);
 917                 return;
 918         }
 919
 920         ret = cal_db_delete_records(view_uri, ids, count);
 921         _cal_server_ipc_return(outdata, ret);
 922
 923         if (CALENDAR_ERROR_NONE == ret) {
 924                 int transaction_ver = 0;
 925                 transaction_ver = cal_db_util_get_transaction_ver();
 926                 ret = cal_ipc_marshal_int(transaction_ver, *outdata);
 927                 if (CALENDAR_ERROR_NONE != ret) {
 928                         ERR("cal_ipc_marshal_int() Fail(%d)", ret);
 929                         pims_ipc_data_destroy(*outdata);
 930                         *outdata = NULL;
 931                         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 932                         _cal_server_ipc_return(outdata, ret);
 933                 }
 934         }
 935
 936         free(ids);
 937         free(view_uri);
 938         cal_handle_destroy(handle);
 939 }
 940
 941 void cal_server_ipc_db_get_changes_by_version(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 942 {
 943         int ret = CALENDAR_ERROR_NONE;
 944
 945         if (NULL == indata) {
 946                 ERR("No indata");
 947                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 948                 _cal_server_ipc_return(outdata, ret);
 949                 return;
 950         }
 951
 952         calendar_h handle = NULL;
 953         ret = cal_ipc_unmarshal_handle(indata, &handle);
 954         if (CALENDAR_ERROR_NONE != ret) {
 955                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
 956                 _cal_server_ipc_return(outdata, ret);
 957                 return;
 958         }
 959
 960         char *view_uri = NULL;
 961         ret = cal_ipc_unmarshal_char(indata, &view_uri);
 962         if (CALENDAR_ERROR_NONE != ret) {
 963                 ERR("cal_ipc_unmarshal_char() Fail(%d)", ret);
 964                 _cal_server_ipc_return(outdata, ret);
 965                 cal_handle_destroy(handle);
 966                 return;
 967         }
 968
 969         int calendar_book_id = 0;
 970         ret = cal_ipc_unmarshal_int(indata, &calendar_book_id);
 971         if (CALENDAR_ERROR_NONE != ret) {
 972                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 973                 _cal_server_ipc_return(outdata, ret);
 974                 free(view_uri);
 975                 cal_handle_destroy(handle);
 976                 return;
 977         }
 978
 979         int calendar_db_version = 0;
 980         ret = cal_ipc_unmarshal_int(indata, &calendar_db_version);
 981         if (CALENDAR_ERROR_NONE != ret) {
 982                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
 983                 _cal_server_ipc_return(outdata, ret);
 984                 free(view_uri);
 985                 cal_handle_destroy(handle);
 986                 return;
 987         }
 988
 989         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_READ)) {
 990                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
 991                 _cal_server_ipc_return(outdata, ret);
 992                 free(view_uri);
 993                 cal_handle_destroy(handle);
 994                 return;
 995         }
 996
 997         calendar_list_h list = NULL;
 998         int current_calendar_db_version = 0;
 999         ret = cal_db_get_changes_by_version(view_uri, calendar_book_id, calendar_db_version, &list, &current_calendar_db_version);
1000         _cal_server_ipc_return(outdata, ret);
1001
1002         if (CALENDAR_ERROR_NONE == ret) {
1003                 ret = cal_ipc_marshal_list(list,*outdata);
1004                 if (CALENDAR_ERROR_NONE != ret) {
1005                         ERR("cal_ipc_marshal_list() Fail(%d)", ret);
1006                         pims_ipc_data_destroy(*outdata);
1007                         *outdata = NULL;
1008                         _cal_server_ipc_return(outdata, ret);
1009                         calendar_list_destroy(list, true);
1010                         free(view_uri);
1011                         cal_handle_destroy(handle);
1012                         return;
1013                 }
1014
1015                 ret = cal_ipc_marshal_int(current_calendar_db_version,*outdata);
1016                 if (CALENDAR_ERROR_NONE != ret) {
1017                         ERR("cal_ipc_marshal_int() Fail(%d)", ret);
1018                         pims_ipc_data_destroy(*outdata);
1019                         *outdata = NULL;
1020                         _cal_server_ipc_return(outdata, ret);
1021                         calendar_list_destroy(list, true);
1022                         free(view_uri);
1023                         cal_handle_destroy(handle);
1024                         return;
1025                 }
1026         }
1027
1028         calendar_list_destroy(list, true);
1029         free(view_uri);
1030         cal_handle_destroy(handle);
1031 }
1032
1033 void cal_server_ipc_db_get_current_version(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1034 {
1035         int ret = CALENDAR_ERROR_NONE;
1036
1037         if (NULL == indata) {
1038                 ERR("No indata");
1039                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
1040                 _cal_server_ipc_return(outdata, ret);
1041                 return;
1042         }
1043
1044         calendar_h handle = NULL;
1045         ret = cal_ipc_unmarshal_handle(indata, &handle);
1046         if (CALENDAR_ERROR_NONE != ret) {
1047                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
1048                 _cal_server_ipc_return(outdata, ret);
1049                 return;
1050         }
1051
1052         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_READ)) {
1053                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
1054                 _cal_server_ipc_return(outdata, ret);
1055                 cal_handle_destroy(handle);
1056                 return;
1057         }
1058
1059         int calendar_db_version = 0;
1060         ret = cal_db_get_current_version(&calendar_db_version);
1061         _cal_server_ipc_return(outdata, ret);
1062
1063         if (CALENDAR_ERROR_NONE == ret) {
1064                 ret = cal_ipc_marshal_int(calendar_db_version, *outdata);
1065                 if (CALENDAR_ERROR_NONE != ret) {
1066                         ERR("cal_ipc_marshal_int() Fail(%d)", ret);
1067                         _cal_server_ipc_return(outdata, ret);
1068                 }
1069         }
1070         cal_handle_destroy(handle);
1071 }
1072
1073 void cal_server_ipc_db_insert_vcalendars(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1074 {
1075         int ret = CALENDAR_ERROR_NONE;
1076
1077         if (NULL == indata) {
1078                 ERR("No indata");
1079                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
1080                 _cal_server_ipc_return(outdata, ret);
1081                 return;
1082         }
1083
1084         calendar_h handle = NULL;
1085         ret = cal_ipc_unmarshal_handle(indata, &handle);
1086         if (CALENDAR_ERROR_NONE != ret) {
1087                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
1088                 _cal_server_ipc_return(outdata, ret);
1089                 return;
1090         }
1091
1092         char *stream = NULL;
1093         ret = cal_ipc_unmarshal_char(indata, &stream);
1094         if (CALENDAR_ERROR_NONE != ret) {
1095                 ERR("cal_ipc_unmarshal_char() Fail(%d)", ret);
1096                 _cal_server_ipc_return(outdata, ret);
1097                 cal_handle_destroy(handle);
1098                 return;
1099         }
1100
1101         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
1102                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
1103                 _cal_server_ipc_return(outdata, ret);
1104                 cal_handle_destroy(handle);
1105                 return;
1106         }
1107
1108         int count = 0;
1109         int *ids = NULL;
1110         ret = cal_db_insert_vcalendars(stream, &ids, &count);
1111         _cal_server_ipc_return(outdata, ret);
1112
1113         if (CALENDAR_ERROR_NONE == ret) {
1114                 int transaction_ver = 0;
1115                 transaction_ver = cal_db_util_get_transaction_ver();
1116                 ret = cal_ipc_marshal_int(transaction_ver, *outdata);
1117                 if (CALENDAR_ERROR_NONE != ret) {
1118                         ERR("cal_ipc_marshal() Fail(%d)", ret);
1119                         pims_ipc_data_destroy(*outdata);
1120                         *outdata = NULL;
1121                         _cal_server_ipc_return(outdata, ret);
1122                         free(ids);
1123                         free(stream);
1124                         cal_handle_destroy(handle);
1125                         return;
1126                 }
1127
1128                 ret = cal_ipc_marshal_int(count, *outdata);
1129                 if (CALENDAR_ERROR_NONE != ret) {
1130                         ERR("cal_ipc_marshal_int() Fail");
1131                         pims_ipc_data_destroy(*outdata);
1132                         *outdata = NULL;
1133                         _cal_server_ipc_return(outdata, ret);
1134                         free(ids);
1135                         free(stream);
1136                         cal_handle_destroy(handle);
1137                         return;
1138                 }
1139
1140                 int i;
1141                 for(i = 0; i < count; i++) {
1142                         ret = cal_ipc_marshal_int(ids[i], *outdata);
1143                         if (CALENDAR_ERROR_NONE != ret) {
1144                                 ERR("cal_ipc_marshal_int() Fail(%d)", ret);
1145                                 pims_ipc_data_destroy(*outdata);
1146                                 *outdata = NULL;
1147                                 _cal_server_ipc_return(outdata, ret);
1148                                 free(ids);
1149                                 free(stream);
1150                                 cal_handle_destroy(handle);
1151                                 return;
1152                         }
1153                 }
1154         }
1155
1156         free(ids);
1157         free(stream);
1158         cal_handle_destroy(handle);
1159 }
1160
1161 void cal_server_ipc_db_replace_vcalendars(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1162 {
1163         int ret = CALENDAR_ERROR_NONE;
1164
1165         if (NULL == indata) {
1166                 ERR("No indata");
1167                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
1168                 _cal_server_ipc_return(outdata, ret);
1169                 return;
1170         }
1171
1172         calendar_h handle = NULL;
1173         ret = cal_ipc_unmarshal_handle(indata, &handle);
1174         if (CALENDAR_ERROR_NONE != ret) {
1175                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
1176                 _cal_server_ipc_return(outdata, ret);
1177                 return;
1178         }
1179
1180         char *stream = NULL;
1181         ret = cal_ipc_unmarshal_char(indata, &stream);
1182         if (CALENDAR_ERROR_NONE != ret) {
1183                 ERR("cal_ipc_unmarshal_char() Fail(%d)", ret);
1184                 _cal_server_ipc_return(outdata, ret);
1185                 cal_handle_destroy(handle);
1186                 return;
1187         }
1188
1189         int count = 0;
1190         ret = cal_ipc_unmarshal_int(indata, &count);
1191         if (CALENDAR_ERROR_NONE != ret) {
1192                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
1193                 _cal_server_ipc_return(outdata, ret);
1194                 free(stream);
1195                 cal_handle_destroy(handle);
1196                 return;
1197         }
1198
1199         int *ids = NULL;
1200         ids = (int*)calloc(count, sizeof(int));
1201         if (NULL == ids) {
1202                 ERR("calloc() Fail");
1203                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1204                 _cal_server_ipc_return(outdata, ret);
1205                 free(stream);
1206                 cal_handle_destroy(handle);
1207                 return;
1208         }
1209
1210         int i = 0;
1211         for(i = 0; i < count; i++) {
1212                 ret = cal_ipc_unmarshal_int(indata, &ids[i]);
1213                 if (CALENDAR_ERROR_NONE != ret) {
1214                         ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
1215                         _cal_server_ipc_return(outdata, ret);
1216                         free(ids);
1217                         free(stream);
1218                         cal_handle_destroy(handle);
1219                         return;
1220                 }
1221         }
1222
1223         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
1224                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
1225                 _cal_server_ipc_return(outdata, ret);
1226                 free(ids);
1227                 free(stream);
1228                 cal_handle_destroy(handle);
1229                 return;
1230         }
1231
1232
1233         ret = cal_db_replace_vcalendars(stream, ids, count);
1234         _cal_server_ipc_return(outdata, ret);
1235
1236         if (CALENDAR_ERROR_NONE == ret) {
1237                 int transaction_ver = 0;
1238                 transaction_ver = cal_db_util_get_transaction_ver();
1239                 ret = cal_ipc_marshal_int(transaction_ver, *outdata);
1240                 if (CALENDAR_ERROR_NONE != ret) {
1241                         ERR("cal_ipc_marshal_int() Fail(%d)", ret);
1242                         pims_ipc_data_destroy(*outdata);
1243                         *outdata = NULL;
1244                         _cal_server_ipc_return(outdata, ret);
1245                 }
1246         }
1247
1248         free(ids);
1249         free(stream);
1250         cal_handle_destroy(handle);
1251 }
1252
1253 void cal_server_ipc_db_replace_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1254 {
1255         int ret = CALENDAR_ERROR_NONE;
1256
1257         if (NULL == indata) {
1258                 ERR("No indata");
1259                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
1260                 _cal_server_ipc_return(outdata, ret);
1261                 return;
1262         }
1263
1264         calendar_h handle = NULL;
1265         ret = cal_ipc_unmarshal_handle(indata, &handle);
1266         if (CALENDAR_ERROR_NONE != ret) {
1267                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
1268                 _cal_server_ipc_return(outdata, ret);
1269                 return;
1270         }
1271
1272         calendar_record_h record = NULL;
1273         ret = cal_ipc_unmarshal_record(indata, &record);
1274         if (CALENDAR_ERROR_NONE != ret) {
1275                 ERR("cal_ipc_unmarshal_record() Fail(%d)", ret);
1276                 _cal_server_ipc_return(outdata, ret);
1277                 cal_handle_destroy(handle);
1278                 return;
1279         }
1280
1281         int id = 0;
1282         ret = cal_ipc_unmarshal_int(indata, &id);
1283         if (CALENDAR_ERROR_NONE != ret) {
1284                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
1285                 _cal_server_ipc_return(outdata, ret);
1286                 calendar_record_destroy(record, true);
1287                 cal_handle_destroy(handle);
1288                 return;
1289         }
1290
1291         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
1292                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
1293                 calendar_record_destroy(record, true);
1294                 cal_handle_destroy(handle);
1295                 return;
1296         }
1297
1298         ret = cal_db_replace_record(record, id);
1299         _cal_server_ipc_return(outdata, ret);
1300
1301         if (CALENDAR_ERROR_NONE == ret) {
1302                 int transaction_ver = 0;
1303                 transaction_ver = cal_db_util_get_transaction_ver();
1304                 ret = cal_ipc_marshal_int(transaction_ver, *outdata);
1305                 if (CALENDAR_ERROR_NONE != ret) {
1306                         ERR("cal_ipc_marshal_int() Fail");
1307                         pims_ipc_data_destroy(*outdata);
1308                         *outdata = NULL;
1309                         _cal_server_ipc_return(outdata, ret);
1310                 }
1311         }
1312
1313         calendar_record_destroy(record, true);
1314         cal_handle_destroy(handle);
1315 }
1316
1317 void cal_server_ipc_db_replace_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1318 {
1319         int ret = CALENDAR_ERROR_NONE;
1320
1321         if (NULL == indata) {
1322                 ERR("No indata");
1323                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
1324                 _cal_server_ipc_return(outdata, ret);
1325                 return;
1326         }
1327
1328         calendar_h handle = NULL;
1329         ret = cal_ipc_unmarshal_handle(indata, &handle);
1330         if (CALENDAR_ERROR_NONE != ret) {
1331                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
1332                 _cal_server_ipc_return(outdata, ret);
1333                 return;
1334         }
1335
1336         calendar_list_h list = NULL;
1337         ret = cal_ipc_unmarshal_list(indata, &list);
1338         if (CALENDAR_ERROR_NONE != ret) {
1339                 ERR("cal_ipc_unmarshal_list() Fail(%d)", ret);
1340                 _cal_server_ipc_return(outdata, ret);
1341                 cal_handle_destroy(handle);
1342                 return;
1343         }
1344
1345         int count = 0;
1346         ret = cal_ipc_unmarshal_int(indata, &count);
1347         if (CALENDAR_ERROR_NONE != ret) {
1348                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
1349                 _cal_server_ipc_return(outdata, ret);
1350                 calendar_list_destroy(list, true);
1351                 cal_handle_destroy(handle);
1352                 return;
1353         }
1354
1355         if (count <= 0) {
1356                 ERR("count(%d) <= 0", count);
1357                 ret = CALENDAR_ERROR_NO_DATA;
1358                 _cal_server_ipc_return(outdata, ret);
1359                 calendar_list_destroy(list, true);
1360                 cal_handle_destroy(handle);
1361                 return;
1362         }
1363
1364         int *ids = NULL;
1365         ids = (int*)calloc(count, sizeof(int));
1366         if (NULL == ids) {
1367                 ERR("calloc() Fail");
1368                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1369                 _cal_server_ipc_return(outdata, ret);
1370                 calendar_list_destroy(list, true);
1371                 cal_handle_destroy(handle);
1372                 return;
1373         }
1374
1375         int i;
1376         for(i = 0; i < count; i++) {
1377                 ret = cal_ipc_unmarshal_int(indata, &ids[i]);
1378                 if (CALENDAR_ERROR_NONE != ret) {
1379                         ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
1380                         ret = CALENDAR_ERROR_IPC;
1381                         _cal_server_ipc_return(outdata, ret);
1382                         free(ids);
1383                         calendar_list_destroy(list, true);
1384                         cal_handle_destroy(handle);
1385                         return;
1386                 }
1387         }
1388
1389         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_WRITE)) {
1390                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
1391                 _cal_server_ipc_return(outdata, ret);
1392                 free(ids);
1393                 calendar_list_destroy(list, true);
1394                 cal_handle_destroy(handle);
1395                 return;
1396         }
1397
1398         ret = cal_db_replace_records(list, ids, count);
1399         _cal_server_ipc_return(outdata, ret);
1400
1401         if (CALENDAR_ERROR_NONE == ret) {
1402                 int transaction_ver = 0;
1403                 transaction_ver = cal_db_util_get_transaction_ver();
1404                 ret = cal_ipc_marshal_int(transaction_ver,*outdata);
1405                 if (CALENDAR_ERROR_NONE != ret) {
1406                         ERR("cal_ipc_marshal_int() Fail");
1407                         pims_ipc_data_destroy(*outdata);
1408                         *outdata = NULL;
1409                         _cal_server_ipc_return(outdata, ret);
1410                 }
1411         }
1412
1413         free(ids);
1414         calendar_list_destroy(list, true);
1415         cal_handle_destroy(handle);
1416 }
1417
1418 void cal_server_ipc_db_changes_exception(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1419 {
1420         int ret = CALENDAR_ERROR_NONE;
1421
1422         if (NULL == indata) {
1423                 ERR("No indata");
1424                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
1425                 _cal_server_ipc_return(outdata, ret);
1426                 return;
1427         }
1428
1429         calendar_h handle = NULL;
1430         ret = cal_ipc_unmarshal_handle(indata, &handle);
1431         if (CALENDAR_ERROR_NONE != ret) {
1432                 ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
1433                 _cal_server_ipc_return(outdata, ret);
1434                 return;
1435         }
1436
1437         char *view_uri = NULL;
1438         ret = cal_ipc_unmarshal_char(indata, &view_uri);
1439         if (CALENDAR_ERROR_NONE != ret) {
1440                 ERR("cal_ipc_unmarshal_char() Fail(%d)", ret);
1441                 _cal_server_ipc_return(outdata, ret);
1442                 cal_handle_destroy(handle);
1443                 return;
1444         }
1445
1446         int original_event_id = 0;
1447         ret = cal_ipc_unmarshal_int(indata, &original_event_id);
1448         if (CALENDAR_ERROR_NONE != ret) {
1449                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
1450                 _cal_server_ipc_return(outdata, ret);
1451                 free(view_uri);
1452                 cal_handle_destroy(handle);
1453                 return;
1454         }
1455
1456         int calendar_db_version = 0;
1457         ret = cal_ipc_unmarshal_int(indata, &calendar_db_version);
1458         if (CALENDAR_ERROR_NONE != ret) {
1459                 ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
1460                 _cal_server_ipc_return(outdata, ret);
1461                 free(view_uri);
1462                 cal_handle_destroy(handle);
1463                 return;
1464         }
1465
1466         if (false == cal_access_control_have_permission(ipc, CAL_PERMISSION_READ)) {
1467                 ret = CALENDAR_ERROR_PERMISSION_DENIED;
1468                 _cal_server_ipc_return(outdata, ret);
1469                 free(view_uri);
1470                 cal_handle_destroy(handle);
1471                 return;
1472         }
1473
1474         calendar_list_h list = NULL;
1475         ret = cal_db_get_changes_exception_by_version(view_uri, original_event_id, calendar_db_version, &list);
1476         _cal_server_ipc_return(outdata, ret);
1477
1478         if (CALENDAR_ERROR_NONE == ret) {
1479                 ret = cal_ipc_marshal_list(list, *outdata);
1480                 if (CALENDAR_ERROR_NONE != ret) {
1481                         ERR("cal_ipc_marshal_list() Fail(%d)", ret);
1482                         ret = CALENDAR_ERROR_IPC;
1483                         _cal_server_ipc_return(outdata, ret);
1484                 }
1485         }
1486
1487         calendar_list_destroy(list, true);
1488         free(view_uri);
1489         cal_handle_destroy(handle);
1490 }