server/cal_server_ipc.c

   1 /*
   2  * Calendar Service
   3  *
   4  * Copyright (c) 2012 - 2013 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
  22 #include "calendar_service.h"
  23 #include "calendar_db.h"
  24 #include "calendar_query.h"
  25 #include "calendar_vcalendar.h"
  26 #include "calendar_reminder.h"
  27
  28 #include "cal_typedef.h"
  29 #include "cal_db.h"
  30 #include "cal_db_util.h"
  31 #include "cal_ipc_marshal.h"
  32 #include "cal_internal.h"
  33 #include "cal_server_ipc.h"
  34
  35 void _cal_server_ipc_connect(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
  36 {
  37     int ret = CALENDAR_ERROR_NONE;
  38
  39     ret = calendar_connect();
  40
  41     if (outdata)
  42     {
  43         *outdata = pims_ipc_data_create(0);
  44         if (!*outdata)
  45         {
  46             ERR("pims_ipc_data_create fail");
  47             return;
  48         }
  49         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
  50         {
  51             pims_ipc_data_destroy(*outdata);
  52             *outdata = NULL;
  53             ERR("pims_ipc_data_put fail");
  54             return;
  55         }
  56     }
  57     else
  58     {
  59         ERR("outdata is NULL");
  60     }
  61     return;
  62 }
  63
  64 void _cal_server_ipc_disconnect(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
  65 {
  66     int ret = CALENDAR_ERROR_NONE;
  67
  68     ret = calendar_disconnect();
  69
  70     if (outdata)
  71     {
  72         *outdata = pims_ipc_data_create(0);
  73         if (!*outdata)
  74         {
  75             ERR("pims_ipc_data_create fail");
  76             return;
  77         }
  78         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
  79         {
  80             pims_ipc_data_destroy(*outdata);
  81             *outdata = NULL;
  82             ERR("pims_ipc_data_put fail");
  83             return;
  84         }
  85     }
  86     else
  87     {
  88         ERR("outdata is NULL");
  89     }
  90     return;
  91 }
  92
  93 // calendar_db.h
  94 void _cal_server_ipc_db_insert_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
  95 {
  96     int ret = CALENDAR_ERROR_NONE;
  97     calendar_record_h record = NULL;
  98     int id = 0;
  99
 100     if (indata)
 101     {
 102         ret = _cal_ipc_unmarshal_record(indata,&record);
 103         if (ret != CALENDAR_ERROR_NONE)
 104         {
 105             ERR("_cal_ipc_unmarshal_record fail");
 106             record = NULL;
 107             goto ERROR_RETURN;
 108         }
 109     }
 110     else
 111     {
 112         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 113         ERR("_cal_server_ipc_db_insert_record fail");
 114         goto ERROR_RETURN;
 115     }
 116
 117     ret = calendar_db_insert_record(record, &id);
 118
 119     if (outdata)
 120     {
 121         *outdata = pims_ipc_data_create(0);
 122         if (!*outdata)
 123         {
 124             ERR("pims_ipc_data_create fail");
 125             goto DATA_FREE;
 126         }
 127         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 128         {
 129             pims_ipc_data_destroy(*outdata);
 130             *outdata = NULL;
 131             ERR("pims_ipc_data_put fail");
 132             goto DATA_FREE;
 133         }
 134         if (ret == CALENDAR_ERROR_NONE)
 135         {
 136             int transaction_ver = _cal_db_util_get_transaction_ver();
 137             if (_cal_ipc_marshal_int(transaction_ver,*outdata) != CALENDAR_ERROR_NONE)
 138             {
 139                 pims_ipc_data_destroy(*outdata);
 140                 *outdata = NULL;
 141                 ERR("_cal_ipc_marshal fail");
 142                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 143                 goto ERROR_RETURN;
 144             }
 145             if (_cal_ipc_marshal_int(id,*outdata) != CALENDAR_ERROR_NONE)
 146             {
 147                 pims_ipc_data_destroy(*outdata);
 148                 *outdata = NULL;
 149                 ERR("_cal_ipc_marshal fail");
 150                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 151                 goto ERROR_RETURN;
 152             }
 153 /*
 154             ret = _cal_ipc_marshal_record_get_primary_id(record, &property_id, &id);
 155
 156             if (ret == CALENDAR_ERROR_NONE)
 157             {
 158                 if (pims_ipc_data_put(*outdata,(void*)&property_id,sizeof(unsigned int)) != 0)
 159                 {
 160                     pims_ipc_data_destroy(*outdata);
 161                     ERR("_cal_ipc_marshal fail");
 162                     ret = CALENDAR_ERROR_INVALID_PARAMETER;
 163                     goto ERROR_RETURN;
 164                 }
 165                 if (_cal_ipc_marshal_int(id,*outdata) != CALENDAR_ERROR_NONE)
 166                 {
 167                     pims_ipc_data_destroy(*outdata);
 168                     ERR("_cal_ipc_marshal fail");
 169                     ret = CALENDAR_ERROR_INVALID_PARAMETER;
 170                     goto ERROR_RETURN;
 171                 }
 172             }
 173             else
 174             {
 175                 pims_ipc_data_destroy(*outdata);
 176                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 177                 goto ERROR_RETURN;
 178             }
 179 */
 180         }
 181     }
 182     else
 183     {
 184         ERR("outdata is NULL");
 185     }
 186     goto DATA_FREE;
 187
 188 ERROR_RETURN:
 189     if (outdata)
 190     {
 191         *outdata = pims_ipc_data_create(0);
 192         if (!*outdata)
 193         {
 194             ERR("pims_ipc_data_create fail");
 195             goto DATA_FREE;
 196         }
 197         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 198         {
 199             pims_ipc_data_destroy(*outdata);
 200             *outdata = NULL;
 201             ERR("pims_ipc_data_put fail");
 202             goto DATA_FREE;
 203         }
 204     }
 205     else
 206     {
 207         ERR("outdata is NULL");
 208     }
 209
 210 DATA_FREE:
 211     if (record)
 212     {
 213         calendar_record_destroy(record,true);
 214     }
 215     return;
 216 }
 217
 218 void _cal_server_ipc_db_get_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 219 {
 220     int ret = CALENDAR_ERROR_NONE;
 221     char* view_uri = NULL;
 222     int id = 0;
 223     calendar_record_h record = NULL;
 224
 225     if (indata)
 226     {
 227         ret = _cal_ipc_unmarshal_char(indata,&view_uri);
 228         if (ret != CALENDAR_ERROR_NONE)
 229         {
 230             ERR("_cal_ipc_unmarshal_char fail");
 231             goto ERROR_RETURN;
 232         }
 233         ret = _cal_ipc_unmarshal_int(indata,&id);
 234         if (ret != CALENDAR_ERROR_NONE)
 235         {
 236             ERR("_cal_ipc_unmarshal_int fail");
 237             goto ERROR_RETURN;
 238         }
 239     }
 240     else
 241     {
 242         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 243         ERR("_cal_server_ipc_db_insert_record fail");
 244         goto ERROR_RETURN;
 245     }
 246
 247     ret = calendar_db_get_record(view_uri,id,&record);
 248
 249 ERROR_RETURN:
 250     if (outdata)
 251     {
 252         *outdata = pims_ipc_data_create(0);
 253         if (!*outdata)
 254         {
 255             ERR("pims_ipc_data_create fail");
 256             goto DATA_FREE;
 257         }
 258         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 259         {
 260             pims_ipc_data_destroy(*outdata);
 261             *outdata = NULL;
 262             ERR("pims_ipc_data_put fail");
 263             goto DATA_FREE;
 264         }
 265         if (_cal_ipc_marshal_record(record, *outdata) != CALENDAR_ERROR_NONE)
 266         {
 267             pims_ipc_data_destroy(*outdata);
 268             *outdata = NULL;
 269             ERR("_cal_ipc_marshal_record fail");
 270             goto DATA_FREE;
 271         }
 272     }
 273     else
 274     {
 275         ERR("outdata is NULL");
 276     }
 277 DATA_FREE:
 278     if (record)
 279     {
 280         calendar_record_destroy(record,true);
 281     }
 282     CAL_FREE(view_uri);
 283     return;
 284 }
 285
 286 void _cal_server_ipc_db_update_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 287 {
 288     int ret = CALENDAR_ERROR_NONE;
 289     calendar_record_h record = NULL;
 290
 291     if (indata)
 292     {
 293         ret = _cal_ipc_unmarshal_record(indata,&record);
 294         if (ret != CALENDAR_ERROR_NONE)
 295         {
 296             ERR("_cal_ipc_unmarshal_record fail");
 297             goto ERROR_RETURN;
 298         }
 299     }
 300     else
 301     {
 302         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 303         ERR("_cal_server_ipc_db_insert_record fail");
 304         goto ERROR_RETURN;
 305     }
 306
 307     ret = calendar_db_update_record(record);
 308
 309 ERROR_RETURN:
 310     if (outdata)
 311     {
 312         *outdata = pims_ipc_data_create(0);
 313         if (!*outdata)
 314         {
 315             ERR("pims_ipc_data_create fail");
 316             goto DATA_FREE;
 317         }
 318         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 319         {
 320             pims_ipc_data_destroy(*outdata);
 321             *outdata = NULL;
 322             ERR("pims_ipc_data_put fail");
 323             goto DATA_FREE;
 324         }
 325         if (ret == CALENDAR_ERROR_NONE)
 326         {
 327             int transaction_ver = _cal_db_util_get_transaction_ver();
 328             if (_cal_ipc_marshal_int(transaction_ver,*outdata) != CALENDAR_ERROR_NONE)
 329             {
 330                 pims_ipc_data_destroy(*outdata);
 331                 ERR("_cal_ipc_marshal fail");
 332                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 333                 goto DATA_FREE;
 334             }
 335         }
 336     }
 337     else
 338     {
 339         ERR("outdata is NULL");
 340     }
 341 DATA_FREE:
 342     if (record)
 343     {
 344         calendar_record_destroy(record,true);
 345     }
 346     return;
 347 }
 348
 349 void _cal_server_ipc_db_delete_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 350 {
 351     int ret = CALENDAR_ERROR_NONE;
 352     char* view_uri = NULL;
 353     int id = 0;
 354
 355     if (indata)
 356     {
 357         ret = _cal_ipc_unmarshal_char(indata,&view_uri);
 358         if (ret != CALENDAR_ERROR_NONE)
 359         {
 360             ERR("_cal_ipc_unmarshal_record fail");
 361             goto ERROR_RETURN;
 362         }
 363         ret = _cal_ipc_unmarshal_int(indata,&id);
 364         if (ret != CALENDAR_ERROR_NONE)
 365         {
 366             ERR("_cal_ipc_unmarshal_int fail");
 367             goto ERROR_RETURN;
 368         }
 369     }
 370     else
 371     {
 372         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 373         ERR("_cal_server_ipc_db_insert_record fail");
 374         goto ERROR_RETURN;
 375     }
 376
 377     ret = calendar_db_delete_record(view_uri,id);
 378
 379 ERROR_RETURN:
 380     if (outdata)
 381     {
 382         *outdata = pims_ipc_data_create(0);
 383         if (!*outdata)
 384         {
 385             ERR("pims_ipc_data_create fail");
 386             goto DATA_FREE;
 387         }
 388         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 389         {
 390             pims_ipc_data_destroy(*outdata);
 391             *outdata = NULL;
 392             ERR("pims_ipc_data_put fail");
 393             goto DATA_FREE;
 394         }
 395         if (ret == CALENDAR_ERROR_NONE)
 396         {
 397             int transaction_ver = _cal_db_util_get_transaction_ver();
 398             if (_cal_ipc_marshal_int(transaction_ver,*outdata) != CALENDAR_ERROR_NONE)
 399             {
 400                 pims_ipc_data_destroy(*outdata);
 401                 ERR("_cal_ipc_marshal fail");
 402                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 403                 goto DATA_FREE;
 404             }
 405         }
 406     }
 407     else
 408     {
 409         ERR("outdata is NULL");
 410     }
 411 DATA_FREE:
 412
 413     CAL_FREE(view_uri);
 414     return;
 415 }
 416
 417 void _cal_server_ipc_db_get_all_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 418 {
 419     int ret = CALENDAR_ERROR_NONE;
 420     char* view_uri = NULL;
 421     int offset = 0;
 422     int limit = 0;
 423     calendar_list_h list = NULL;
 424
 425     if (indata)
 426     {
 427         ret = _cal_ipc_unmarshal_char(indata,&view_uri);
 428         if (ret != CALENDAR_ERROR_NONE)
 429         {
 430             ERR("_cal_ipc_unmarshal_record fail");
 431             goto ERROR_RETURN;
 432         }
 433         ret = _cal_ipc_unmarshal_int(indata,&offset);
 434         if (ret != CALENDAR_ERROR_NONE)
 435         {
 436             ERR("_cal_ipc_unmarshal_int fail");
 437             goto ERROR_RETURN;
 438         }
 439         ret = _cal_ipc_unmarshal_int(indata,&limit);
 440         if (ret != CALENDAR_ERROR_NONE)
 441         {
 442             ERR("_cal_ipc_unmarshal_int fail");
 443             goto ERROR_RETURN;
 444         }
 445     }
 446     else
 447     {
 448         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 449         ERR("_cal_server_ipc_db_insert_record fail");
 450         goto ERROR_RETURN;
 451     }
 452
 453     ret = calendar_db_get_all_records(view_uri,offset,limit,&list);
 454
 455     if (outdata)
 456     {
 457         *outdata = pims_ipc_data_create(0);
 458         if (!*outdata)
 459         {
 460             ERR("pims_ipc_data_create fail");
 461             goto DATA_FREE;
 462         }
 463         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 464         {
 465             pims_ipc_data_destroy(*outdata);
 466             *outdata = NULL;
 467             ERR("pims_ipc_data_put fail");
 468             goto DATA_FREE;
 469         }
 470         ret = _cal_ipc_marshal_list(list,*outdata);
 471
 472         if (ret != CALENDAR_ERROR_NONE)
 473         {
 474             ERR("_cal_ipc_unmarshal_int fail");
 475             goto ERROR_RETURN;
 476         }
 477     }
 478     else
 479     {
 480         ERR("outdata is NULL");
 481     }
 482
 483     goto DATA_FREE;
 484
 485 ERROR_RETURN:
 486     if (outdata)
 487     {
 488         *outdata = pims_ipc_data_create(0);
 489         if (!*outdata)
 490         {
 491             ERR("pims_ipc_data_create fail");
 492             goto DATA_FREE;
 493         }
 494         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 495         {
 496             pims_ipc_data_destroy(*outdata);
 497             *outdata = NULL;
 498             ERR("pims_ipc_data_put fail");
 499             goto DATA_FREE;
 500         }
 501     }
 502     else
 503     {
 504         ERR("outdata is NULL");
 505     }
 506 DATA_FREE:
 507
 508     if (list)
 509     {
 510         calendar_list_destroy(list,true);
 511     }
 512     CAL_FREE(view_uri);
 513     return;
 514 }
 515
 516 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)
 517 {
 518     int ret = CALENDAR_ERROR_NONE;
 519     calendar_query_h query = NULL;
 520     int offset = 0;
 521     int limit = 0;
 522     calendar_list_h list = NULL;
 523
 524     if (indata)
 525     {
 526         ret = _cal_ipc_unmarshal_query(indata,&query);
 527         if (ret != CALENDAR_ERROR_NONE)
 528         {
 529             ERR("_cal_ipc_unmarshal_record fail");
 530             goto ERROR_RETURN;
 531         }
 532         ret = _cal_ipc_unmarshal_int(indata,&offset);
 533         if (ret != CALENDAR_ERROR_NONE)
 534         {
 535             ERR("_cal_ipc_unmarshal_int fail");
 536             goto ERROR_RETURN;
 537         }
 538         ret = _cal_ipc_unmarshal_int(indata,&limit);
 539         if (ret != CALENDAR_ERROR_NONE)
 540         {
 541             ERR("_cal_ipc_unmarshal_int fail");
 542             goto ERROR_RETURN;
 543         }
 544     }
 545     else
 546     {
 547         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 548         ERR("_cal_server_ipc_db_insert_record fail");
 549         goto ERROR_RETURN;
 550     }
 551
 552     ret = calendar_db_get_records_with_query(query,offset,limit,&list);
 553
 554     if (outdata)
 555     {
 556         *outdata = pims_ipc_data_create(0);
 557         if (!*outdata)
 558         {
 559             ERR("pims_ipc_data_create fail");
 560             goto DATA_FREE;
 561         }
 562         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 563         {
 564             pims_ipc_data_destroy(*outdata);
 565             *outdata = NULL;
 566             ERR("pims_ipc_data_put fail");
 567             goto DATA_FREE;
 568         }
 569         ret = _cal_ipc_marshal_list(list,*outdata);
 570
 571         if (ret != CALENDAR_ERROR_NONE)
 572         {
 573             ERR("_cal_ipc_unmarshal_int fail");
 574             goto ERROR_RETURN;
 575         }
 576     }
 577     else
 578     {
 579         ERR("outdata is NULL");
 580     }
 581     goto DATA_FREE;
 582
 583 ERROR_RETURN:
 584     if (outdata)
 585     {
 586         *outdata = pims_ipc_data_create(0);
 587         if (!*outdata)
 588         {
 589             ERR("pims_ipc_data_create fail");
 590             goto DATA_FREE;
 591         }
 592         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 593         {
 594             pims_ipc_data_destroy(*outdata);
 595             *outdata = NULL;
 596             ERR("pims_ipc_data_put fail");
 597             goto DATA_FREE;
 598         }
 599     }
 600     else
 601     {
 602         ERR("outdata is NULL");
 603     }
 604 DATA_FREE:
 605
 606     if (list)
 607     {
 608         calendar_list_destroy(list,true);
 609     }
 610     if (query)
 611     {
 612         calendar_query_destroy(query);
 613     }
 614     return;
 615 }
 616
 617 void _cal_server_ipc_db_clean_after_sync(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 618 {
 619     int ret = CALENDAR_ERROR_NONE;
 620     int calendar_book_id = 0;
 621
 622     if (indata)
 623     {
 624         ret = _cal_ipc_unmarshal_int(indata,&calendar_book_id);
 625         if (ret != CALENDAR_ERROR_NONE)
 626         {
 627             ERR("_cal_ipc_unmarshal_int fail");
 628             goto ERROR_RETURN;
 629         }
 630     }
 631     else
 632     {
 633         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 634         ERR("_cal_server_ipc_db_insert_record fail");
 635         goto ERROR_RETURN;
 636     }
 637
 638     ret = calendar_db_clean_after_sync(calendar_book_id);
 639
 640 ERROR_RETURN:
 641     if (outdata)
 642     {
 643         *outdata = pims_ipc_data_create(0);
 644         if (!*outdata)
 645         {
 646             ERR("pims_ipc_data_create fail");
 647             return;
 648         }
 649         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 650         {
 651             pims_ipc_data_destroy(*outdata);
 652             *outdata = NULL;
 653             ERR("pims_ipc_data_put fail");
 654             return;
 655         }
 656     }
 657     else
 658     {
 659         ERR("outdata is NULL");
 660     }
 661
 662     return;
 663 }
 664
 665 void _cal_server_ipc_db_get_count(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 666 {
 667     int ret = CALENDAR_ERROR_NONE;
 668     char* view_uri = NULL;
 669     int count = 0;
 670
 671     if (indata)
 672     {
 673         ret = _cal_ipc_unmarshal_char(indata,&view_uri);
 674         if (ret != CALENDAR_ERROR_NONE)
 675         {
 676             ERR("_cal_ipc_unmarshal_record fail");
 677             goto ERROR_RETURN;
 678         }
 679     }
 680     else
 681     {
 682         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 683         ERR("_cal_server_ipc_db_insert_record fail");
 684         goto ERROR_RETURN;
 685     }
 686
 687     ret = calendar_db_get_count(view_uri,&count);
 688
 689     if (outdata)
 690     {
 691         *outdata = pims_ipc_data_create(0);
 692         if (!*outdata)
 693         {
 694             ERR("pims_ipc_data_create fail");
 695             goto DATA_FREE;
 696         }
 697         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 698         {
 699             pims_ipc_data_destroy(*outdata);
 700             *outdata = NULL;
 701             ERR("pims_ipc_data_put fail");
 702             goto DATA_FREE;
 703         }
 704         ret = _cal_ipc_marshal_int(count,*outdata);
 705
 706         if (ret != CALENDAR_ERROR_NONE)
 707         {
 708             ERR("_cal_ipc_unmarshal_int fail");
 709             goto ERROR_RETURN;
 710         }
 711     }
 712     else
 713     {
 714         ERR("outdata is NULL");
 715     }
 716     goto DATA_FREE;
 717
 718 ERROR_RETURN:
 719     if (outdata)
 720     {
 721         *outdata = pims_ipc_data_create(0);
 722         if (!*outdata)
 723         {
 724             ERR("pims_ipc_data_create fail");
 725             goto DATA_FREE;
 726         }
 727         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 728         {
 729             pims_ipc_data_destroy(*outdata);
 730             *outdata = NULL;
 731             ERR("pims_ipc_data_put fail");
 732             goto DATA_FREE;
 733         }
 734     }
 735     else
 736     {
 737         ERR("outdata is NULL");
 738     }
 739 DATA_FREE:
 740     CAL_FREE(view_uri);
 741     return;
 742 }
 743
 744 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)
 745 {
 746     int ret = CALENDAR_ERROR_NONE;
 747     calendar_query_h query = NULL;
 748     int count = 0;
 749
 750     if (indata)
 751     {
 752         ret = _cal_ipc_unmarshal_query(indata,&query);
 753         if (ret != CALENDAR_ERROR_NONE)
 754         {
 755             ERR("_cal_ipc_unmarshal_record fail");
 756             goto ERROR_RETURN;
 757         }
 758     }
 759     else
 760     {
 761         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 762         ERR("_cal_server_ipc_db_insert_record fail");
 763         goto ERROR_RETURN;
 764     }
 765
 766     ret = calendar_db_get_count_with_query(query,&count);
 767
 768     if (outdata)
 769     {
 770         *outdata = pims_ipc_data_create(0);
 771         if (!*outdata)
 772         {
 773             ERR("pims_ipc_data_create fail");
 774             goto DATA_FREE;
 775         }
 776         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 777         {
 778             pims_ipc_data_destroy(*outdata);
 779             *outdata = NULL;
 780             ERR("pims_ipc_data_put fail");
 781             goto DATA_FREE;
 782         }
 783         ret = _cal_ipc_marshal_int(count,*outdata);
 784
 785         if (ret != CALENDAR_ERROR_NONE)
 786         {
 787             ERR("_cal_ipc_unmarshal_int fail");
 788             goto ERROR_RETURN;
 789         }
 790     }
 791     else
 792     {
 793         ERR("outdata is NULL");
 794     }
 795     goto DATA_FREE;
 796
 797 ERROR_RETURN:
 798     if (outdata)
 799     {
 800         *outdata = pims_ipc_data_create(0);
 801         if (!*outdata)
 802         {
 803             ERR("pims_ipc_data_create fail");
 804             goto DATA_FREE;
 805         }
 806         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 807         {
 808             pims_ipc_data_destroy(*outdata);
 809             *outdata = NULL;
 810             ERR("pims_ipc_data_put fail");
 811             goto DATA_FREE;
 812         }
 813     }
 814     else
 815     {
 816         ERR("outdata is NULL");
 817     }
 818 DATA_FREE:
 819     if (query)
 820     {
 821         calendar_query_destroy(query);
 822     }
 823     return;
 824 }
 825
 826 void _cal_server_ipc_db_insert_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 827 {
 828     int ret = CALENDAR_ERROR_NONE;
 829     calendar_list_h list = NULL;
 830     int id_count = 0;
 831     int *ids = NULL;
 832     int i=0;
 833
 834     if (indata)
 835     {
 836         ret = _cal_ipc_unmarshal_list(indata,&list);
 837         if (ret != CALENDAR_ERROR_NONE)
 838         {
 839             ERR("_cal_ipc_unmarshal_list fail");
 840             goto ERROR_RETURN;
 841         }
 842     }
 843     else
 844     {
 845         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 846         ERR("_cal_server_ipc_db_insert_record fail");
 847         goto ERROR_RETURN;
 848     }
 849
 850     ret = calendar_db_insert_records(list, &ids, &id_count);
 851
 852     if (outdata)
 853     {
 854         *outdata = pims_ipc_data_create(0);
 855         if (!*outdata)
 856         {
 857             ERR("pims_ipc_data_create fail");
 858             goto DATA_FREE;
 859         }
 860         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 861         {
 862             pims_ipc_data_destroy(*outdata);
 863             *outdata = NULL;
 864             ERR("pims_ipc_data_put fail");
 865             goto DATA_FREE;
 866         }
 867
 868         if(ret == CALENDAR_ERROR_NONE)
 869         {
 870             int transaction_ver = _cal_db_util_get_transaction_ver();
 871             if (_cal_ipc_marshal_int(transaction_ver,*outdata) != CALENDAR_ERROR_NONE)
 872             {
 873                 pims_ipc_data_destroy(*outdata);
 874                 ERR("_cal_ipc_marshal fail");
 875                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 876                 goto ERROR_RETURN;
 877             }
 878             // marshal : id_count+[ids]*id_count
 879             // id_count
 880             if (pims_ipc_data_put(*outdata,(void*)&id_count,sizeof(int)) != 0)
 881             {
 882                 pims_ipc_data_destroy(*outdata);
 883                 *outdata = NULL;
 884                 ERR("pims_ipc_data_put fail");
 885                 ret = CALENDAR_ERROR_INVALID_PARAMETER;
 886                 goto ERROR_RETURN;
 887             }
 888
 889             for(i=0;i<id_count;i++)
 890             {
 891                 // marshal ids
 892                 if (pims_ipc_data_put(*outdata,(void*)&ids[i],sizeof(int)) != 0)
 893                 {
 894                     pims_ipc_data_destroy(*outdata);
 895                     *outdata = NULL;
 896                     ERR("pims_ipc_data_put fail");
 897                     ret = CALENDAR_ERROR_INVALID_PARAMETER;
 898                     goto ERROR_RETURN;
 899                 }
 900             }
 901         }
 902     }
 903     else
 904     {
 905         ERR("outdata is NULL");
 906     }
 907     goto DATA_FREE;
 908
 909 ERROR_RETURN:
 910     if (outdata)
 911     {
 912         *outdata = pims_ipc_data_create(0);
 913         if (!*outdata)
 914         {
 915             ERR("pims_ipc_data_create fail");
 916             goto DATA_FREE;
 917         }
 918         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 919         {
 920             pims_ipc_data_destroy(*outdata);
 921             *outdata = NULL;
 922             ERR("pims_ipc_data_put fail");
 923             goto DATA_FREE;
 924         }
 925     }
 926     else
 927     {
 928         ERR("outdata is NULL");
 929     }
 930 DATA_FREE:
 931     if (list)
 932     {
 933         calendar_list_destroy(list,true);
 934     }
 935     CAL_FREE(ids);
 936     return;
 937 }
 938
 939 void _cal_server_ipc_db_update_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
 940 {
 941     int ret = CALENDAR_ERROR_NONE;
 942     calendar_list_h list = NULL;
 943
 944     if (indata)
 945     {
 946         ret = _cal_ipc_unmarshal_list(indata,&list);
 947         if (ret != CALENDAR_ERROR_NONE)
 948         {
 949             ERR("_cal_ipc_unmarshal_list fail");
 950             goto ERROR_RETURN;
 951         }
 952     }
 953     else
 954     {
 955         ret = CALENDAR_ERROR_INVALID_PARAMETER;
 956         ERR("_cal_server_ipc_db_insert_record fail");
 957         goto ERROR_RETURN;
 958     }
 959
 960     ret = calendar_db_update_records(list);
 961
 962     if (outdata)
 963     {
 964         *outdata = pims_ipc_data_create(0);
 965         if (!*outdata)
 966         {
 967             ERR("pims_ipc_data_create fail");
 968             goto DATA_FREE;
 969         }
 970         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
 971         {
 972             pims_ipc_data_destroy(*outdata);
 973             *outdata = NULL;
 974             ERR("pims_ipc_data_put fail");
 975             goto DATA_FREE;
 976         }
 977         if (ret == CALENDAR_ERROR_NONE)
 978         {
 979             int transaction_ver = _cal_db_util_get_transaction_ver();
 980             if (_cal_ipc_marshal_int(transaction_ver,*outdata) != CALENDAR_ERROR_NONE)
 981             {
 982                 pims_ipc_data_destroy(*outdata);
 983                 ERR("_cal_ipc_marshal fail");
 984                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 985                 goto DATA_FREE;
 986             }
 987         }
 988     }
 989     else
 990     {
 991         ERR("outdata is NULL");
 992     }
 993     goto DATA_FREE;
 994
 995 ERROR_RETURN:
 996     if (outdata)
 997     {
 998         *outdata = pims_ipc_data_create(0);
 999         if (!*outdata)
1000         {
1001             ERR("pims_ipc_data_create fail");
1002             goto DATA_FREE;
1003         }
1004         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1005         {
1006             pims_ipc_data_destroy(*outdata);
1007             *outdata = NULL;
1008             ERR("pims_ipc_data_put fail");
1009             goto DATA_FREE;
1010         }
1011     }
1012     else
1013     {
1014         ERR("outdata is NULL");
1015     }
1016 DATA_FREE:
1017     if (list)
1018     {
1019         calendar_list_destroy(list,true);
1020     }
1021     return;
1022 }
1023
1024 void _cal_server_ipc_db_delete_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1025 {
1026     int ret = CALENDAR_ERROR_NONE;
1027     int count = 0;
1028     int *ids = NULL;
1029     char *uri = NULL;
1030     int i = 0;
1031
1032     if (indata)
1033     {
1034         ret = _cal_ipc_unmarshal_char(indata,&uri);
1035         if (ret != CALENDAR_ERROR_NONE)
1036         {
1037             ERR("_cal_ipc_unmarshal_char fail");
1038             goto ERROR_RETURN;
1039         }
1040         ret = _cal_ipc_unmarshal_int(indata,&count);
1041         if (ret != CALENDAR_ERROR_NONE)
1042         {
1043             ERR("_cal_ipc_unmarshal_int fail");
1044             goto ERROR_RETURN;
1045         }
1046         if (count <=0)
1047         {
1048             goto ERROR_RETURN;
1049         }
1050         ids = (int*)malloc(sizeof(int)*count);
1051         for(i=0;i<count;i++)
1052         {
1053             ret = _cal_ipc_unmarshal_int(indata,&ids[i]);
1054             if (ret != CALENDAR_ERROR_NONE)
1055             {
1056                 ERR("_cal_ipc_unmarshal_int fail");
1057                 goto ERROR_RETURN;
1058             }
1059         }
1060     }
1061     else
1062     {
1063         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1064         ERR("_cal_server_ipc_db_insert_record fail");
1065         goto ERROR_RETURN;
1066     }
1067
1068     ret = calendar_db_delete_records(uri,ids,count);
1069
1070     if (outdata)
1071     {
1072         *outdata = pims_ipc_data_create(0);
1073         if (!*outdata)
1074         {
1075             ERR("pims_ipc_data_create fail");
1076             goto DATA_FREE;
1077         }
1078         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1079         {
1080             pims_ipc_data_destroy(*outdata);
1081             *outdata = NULL;
1082             ERR("pims_ipc_data_put fail");
1083             goto DATA_FREE;
1084         }
1085         if (ret == CALENDAR_ERROR_NONE)
1086         {
1087             int transaction_ver = _cal_db_util_get_transaction_ver();
1088             if (_cal_ipc_marshal_int(transaction_ver,*outdata) != CALENDAR_ERROR_NONE)
1089             {
1090                 pims_ipc_data_destroy(*outdata);
1091                 ERR("_cal_ipc_marshal fail");
1092                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1093                 goto DATA_FREE;
1094             }
1095         }
1096     }
1097     else
1098     {
1099         ERR("outdata is NULL");
1100     }
1101     goto DATA_FREE;
1102
1103 ERROR_RETURN:
1104     if (outdata)
1105     {
1106         *outdata = pims_ipc_data_create(0);
1107         if (!*outdata)
1108         {
1109             ERR("pims_ipc_data_create fail");
1110             goto DATA_FREE;
1111         }
1112         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1113         {
1114             pims_ipc_data_destroy(*outdata);
1115             *outdata = NULL;
1116             ERR("pims_ipc_data_put fail");
1117             goto DATA_FREE;
1118         }
1119     }
1120     else
1121     {
1122         ERR("outdata is NULL");
1123     }
1124 DATA_FREE:
1125     CAL_FREE(uri);
1126     CAL_FREE(ids);
1127     return;
1128 }
1129
1130 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)
1131 {
1132     int ret = CALENDAR_ERROR_NONE;
1133     char* view_uri = NULL;
1134     int calendar_book_id = 0;
1135     int calendar_db_version = 0;
1136     calendar_list_h record_list = NULL;
1137     int current_calendar_db_version = 0;
1138
1139     if (indata)
1140     {
1141         ret = _cal_ipc_unmarshal_char(indata,&view_uri);
1142         if (ret != CALENDAR_ERROR_NONE)
1143         {
1144             ERR("_cal_ipc_unmarshal_char fail");
1145             goto ERROR_RETURN;
1146         }
1147         ret = _cal_ipc_unmarshal_int(indata,&calendar_book_id);
1148         if (ret != CALENDAR_ERROR_NONE)
1149         {
1150             ERR("_cal_ipc_unmarshal_int fail");
1151             goto ERROR_RETURN;
1152         }
1153         ret = _cal_ipc_unmarshal_int(indata,&calendar_db_version);
1154         if (ret != CALENDAR_ERROR_NONE)
1155         {
1156             ERR("_cal_ipc_unmarshal_int fail");
1157             goto ERROR_RETURN;
1158         }
1159     }
1160     else
1161     {
1162         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1163         ERR("_cal_server_ipc_db_insert_record fail");
1164         goto ERROR_RETURN;
1165     }
1166
1167     ret = calendar_db_get_changes_by_version(view_uri,calendar_book_id,calendar_db_version,&record_list,&current_calendar_db_version);
1168
1169     if (outdata)
1170     {
1171         *outdata = pims_ipc_data_create(0);
1172         if (!*outdata)
1173         {
1174             ERR("pims_ipc_data_create fail");
1175             goto DATA_FREE;
1176         }
1177         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1178         {
1179             pims_ipc_data_destroy(*outdata);
1180             *outdata = NULL;
1181             ERR("pims_ipc_data_put fail");
1182             goto DATA_FREE;
1183         }
1184         ret = _cal_ipc_marshal_list(record_list,*outdata);
1185         if (ret != CALENDAR_ERROR_NONE)
1186         {
1187             ERR("_cal_ipc_marshal_list fail");
1188             goto ERROR_RETURN;
1189         }
1190         ret = _cal_ipc_marshal_int(current_calendar_db_version,*outdata);
1191         if (ret != CALENDAR_ERROR_NONE)
1192         {
1193             ERR("_cal_ipc_unmarshal_int fail");
1194             goto ERROR_RETURN;
1195         }
1196     }
1197     else
1198     {
1199         ERR("outdata is NULL");
1200     }
1201     goto DATA_FREE;
1202
1203 ERROR_RETURN:
1204     if (outdata)
1205     {
1206         *outdata = pims_ipc_data_create(0);
1207         if (!*outdata)
1208         {
1209             ERR("pims_ipc_data_create fail");
1210             goto DATA_FREE;
1211         }
1212         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1213         {
1214             pims_ipc_data_destroy(*outdata);
1215             *outdata = NULL;
1216             ERR("pims_ipc_data_put fail");
1217             goto DATA_FREE;
1218         }
1219     }
1220     else
1221     {
1222         ERR("outdata is NULL");
1223     }
1224 DATA_FREE:
1225     if (record_list)
1226     {
1227         calendar_list_destroy(record_list,true);
1228     }
1229     CAL_FREE(view_uri);
1230     return;
1231 }
1232
1233 void _cal_server_ipc_db_get_current_version(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1234 {
1235     int ret = CALENDAR_ERROR_NONE;
1236     int calendar_db_version = 0;
1237
1238     ret = calendar_db_get_current_version(&calendar_db_version);
1239
1240     if (outdata)
1241     {
1242         *outdata = pims_ipc_data_create(0);
1243         if (!*outdata)
1244         {
1245             ERR("pims_ipc_data_create fail");
1246             return;
1247         }
1248         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1249         {
1250             pims_ipc_data_destroy(*outdata);
1251             *outdata = NULL;
1252             ERR("pims_ipc_data_put fail");
1253             return;
1254         }
1255         ret = _cal_ipc_marshal_int(calendar_db_version,*outdata);
1256         if (ret != CALENDAR_ERROR_NONE)
1257         {
1258             ERR("_cal_ipc_marshal_int fail");
1259             return;
1260         }
1261     }
1262     else
1263     {
1264         ERR("outdata is NULL");
1265     }
1266     return;
1267 }
1268
1269 void _cal_server_ipc_db_insert_vcalendars(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1270 {
1271     int ret = CALENDAR_ERROR_NONE;
1272     char *stream = NULL;
1273     int count = 0;
1274     int *ids = NULL;
1275     int i = 0;
1276
1277     if (indata)
1278     {
1279         ret = _cal_ipc_unmarshal_char(indata, &stream);
1280         if (ret != CALENDAR_ERROR_NONE)
1281         {
1282             ERR("unmarshal fail");
1283             goto ERROR_RETURN;
1284         }
1285     }
1286     else
1287     {
1288         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1289         ERR("db_insert_vcalendars fail.");
1290         goto ERROR_RETURN;
1291     }
1292
1293     ret = calendar_db_insert_vcalendars(stream, &ids, &count);
1294
1295     if (ret != CALENDAR_ERROR_NONE)
1296     {
1297         ERR("calendar_db_insert_vcalendars fail");
1298         goto ERROR_RETURN;
1299     }
1300
1301     if (outdata)
1302     {
1303         *outdata = pims_ipc_data_create(0);
1304         if (!*outdata)
1305         {
1306             ERR("pims_ipc_data_create fail");
1307             goto DATA_FREE;
1308         }
1309         // return
1310         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1311         {
1312             pims_ipc_data_destroy(*outdata);
1313             *outdata = NULL;
1314             ERR("pims_ipc_data_put fail");
1315             goto DATA_FREE;
1316         }
1317         if (ret == CALENDAR_ERROR_NONE)
1318         {
1319             int transaction_ver = _cal_db_util_get_transaction_ver();
1320             if (_cal_ipc_marshal_int(transaction_ver,*outdata) != CALENDAR_ERROR_NONE)
1321             {
1322                 pims_ipc_data_destroy(*outdata);
1323                 *outdata = NULL;
1324                 ERR("_cal_ipc_marshal fail");
1325                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1326                 goto ERROR_RETURN;
1327             }
1328         }
1329         // count
1330         ret = _cal_ipc_marshal_int(count,*outdata);
1331         if (ret != CALENDAR_ERROR_NONE)
1332         {
1333             pims_ipc_data_destroy(*outdata);
1334             *outdata = NULL;
1335             ERR("_cal_ipc_marshal_list fail");
1336             goto ERROR_RETURN;
1337         }
1338         for(i=0;i<count;i++)
1339         {
1340             ret = _cal_ipc_marshal_int(ids[i],*outdata);
1341             if (ret != CALENDAR_ERROR_NONE)
1342             {
1343                 pims_ipc_data_destroy(*outdata);
1344                 *outdata = NULL;
1345                 ERR("_cal_ipc_marshal_list fail");
1346                 goto ERROR_RETURN;
1347             }
1348         }
1349     }
1350     else
1351     {
1352         ERR("outdata is NULL");
1353     }
1354     goto DATA_FREE;
1355
1356 ERROR_RETURN:
1357     if (outdata)
1358     {
1359         *outdata = pims_ipc_data_create(0);
1360         if (!*outdata)
1361         {
1362             ERR("pims_ipc_data_create fail");
1363             goto DATA_FREE;
1364         }
1365         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1366         {
1367             pims_ipc_data_destroy(*outdata);
1368             *outdata = NULL;
1369             ERR("pims_ipc_data_put fail");
1370             goto DATA_FREE;
1371         }
1372     }
1373     else
1374     {
1375         ERR("outdata is NULL");
1376     }
1377 DATA_FREE:
1378     CAL_FREE(stream);
1379     CAL_FREE(ids);
1380     return;
1381 }
1382
1383 void _cal_server_ipc_db_replace_vcalendars(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1384 {
1385     int ret = CALENDAR_ERROR_NONE;
1386     char *stream = NULL;
1387     int count = 0;
1388     int *ids = NULL;
1389     int i = 0;
1390
1391     if (indata)
1392     {
1393         ret = _cal_ipc_unmarshal_char(indata, &stream);
1394         if (ret != CALENDAR_ERROR_NONE)
1395         {
1396             ERR("unmarshal fail");
1397             goto ERROR_RETURN;
1398         }
1399         ret = _cal_ipc_unmarshal_int(indata, &count);
1400         if (ret != CALENDAR_ERROR_NONE)
1401         {
1402             ERR("unmarshal fail");
1403             goto ERROR_RETURN;
1404         }
1405         ids = (int*)malloc(sizeof(int)*count);
1406         if (ids == NULL)
1407         {
1408             ERR("malloc fail");
1409             goto ERROR_RETURN;
1410         }
1411         for(i=0;i<count;i++)
1412         {
1413             ret = _cal_ipc_unmarshal_int(indata, &ids[i]);
1414             if (ret != CALENDAR_ERROR_NONE)
1415             {
1416                 ERR("unmarshal fail");
1417                 goto ERROR_RETURN;
1418             }
1419         }
1420     }
1421     else
1422     {
1423         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1424         ERR("db_replace_vcalendars fail.");
1425         goto ERROR_RETURN;
1426     }
1427
1428     ret = calendar_db_replace_vcalendars(stream, ids, count);
1429
1430     if (ret != CALENDAR_ERROR_NONE)
1431     {
1432         ERR("calendar_db_insert_vcalendars fail");
1433         goto ERROR_RETURN;
1434     }
1435
1436     if (outdata)
1437     {
1438         *outdata = pims_ipc_data_create(0);
1439         if (!*outdata)
1440         {
1441             ERR("pims_ipc_data_create fail");
1442             goto DATA_FREE;
1443         }
1444         // return
1445         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1446         {
1447             pims_ipc_data_destroy(*outdata);
1448             *outdata = NULL;
1449             ERR("pims_ipc_data_put fail");
1450             goto DATA_FREE;
1451         }
1452         if (ret == CALENDAR_ERROR_NONE)
1453         {
1454             int transaction_ver = _cal_db_util_get_transaction_ver();
1455             if (_cal_ipc_marshal_int(transaction_ver,*outdata) != CALENDAR_ERROR_NONE)
1456             {
1457                 pims_ipc_data_destroy(*outdata);
1458                 *outdata = NULL;
1459                 ERR("_cal_ipc_marshal fail");
1460                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1461                 goto DATA_FREE;
1462             }
1463         }
1464     }
1465     else
1466     {
1467         ERR("outdata is NULL");
1468     }
1469     goto DATA_FREE;
1470
1471 ERROR_RETURN:
1472     if (outdata)
1473     {
1474         *outdata = pims_ipc_data_create(0);
1475         if (!*outdata)
1476         {
1477             ERR("pims_ipc_data_create fail");
1478             goto DATA_FREE;
1479         }
1480         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1481         {
1482             pims_ipc_data_destroy(*outdata);
1483             *outdata = NULL;
1484             ERR("pims_ipc_data_put fail");
1485             goto DATA_FREE;
1486         }
1487     }
1488     else
1489     {
1490         ERR("outdata is NULL");
1491     }
1492 DATA_FREE:
1493     CAL_FREE(stream);
1494     CAL_FREE(ids);
1495     return;
1496 }
1497
1498 void _cal_server_ipc_db_replace_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1499 {
1500     int ret = CALENDAR_ERROR_NONE;
1501         int id = 0;
1502     calendar_record_h record = NULL;
1503
1504     if (indata)
1505     {
1506         ret = _cal_ipc_unmarshal_record(indata,&record);
1507         if (ret != CALENDAR_ERROR_NONE)
1508         {
1509             ERR("_cal_ipc_unmarshal_record fail");
1510             goto ERROR_RETURN;
1511         }
1512         ret = _cal_ipc_unmarshal_int(indata,&id);
1513         if (ret != CALENDAR_ERROR_NONE)
1514         {
1515             ERR("_cal_ipc_unmarshal_record fail");
1516             goto ERROR_RETURN;
1517         }
1518     }
1519
1520     else
1521     {
1522         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1523         ERR("_cal_server_ipc_db_insert_record fail");
1524         goto ERROR_RETURN;
1525     }
1526
1527     ret = calendar_db_replace_record(record, id);
1528
1529 ERROR_RETURN:
1530     if (outdata)
1531     {
1532         *outdata = pims_ipc_data_create(0);
1533         if (!*outdata)
1534         {
1535             ERR("pims_ipc_data_create fail");
1536             goto DATA_FREE;
1537         }
1538         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1539         {
1540             pims_ipc_data_destroy(*outdata);
1541             *outdata = NULL;
1542             ERR("pims_ipc_data_put fail");
1543             goto DATA_FREE;
1544         }
1545         if (ret == CALENDAR_ERROR_NONE)
1546         {
1547             int transaction_ver = _cal_db_util_get_transaction_ver();
1548             if (_cal_ipc_marshal_int(transaction_ver,*outdata) != CALENDAR_ERROR_NONE)
1549             {
1550                 pims_ipc_data_destroy(*outdata);
1551                 *outdata = NULL;
1552                 ERR("_cal_ipc_marshal fail");
1553                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1554                 goto DATA_FREE;
1555             }
1556         }
1557     }
1558     else
1559     {
1560         ERR("outdata is NULL");
1561     }
1562 DATA_FREE:
1563     if (record)
1564     {
1565         calendar_record_destroy(record,true);
1566     }
1567     return;
1568 }
1569
1570 void _cal_server_ipc_db_replace_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1571 {
1572     int ret = CALENDAR_ERROR_NONE;
1573         int i;
1574     int count = 0;
1575     int *ids = NULL;
1576     calendar_list_h list = NULL;
1577
1578     if (indata)
1579     {
1580         ret = _cal_ipc_unmarshal_list(indata,&list);
1581         if (ret != CALENDAR_ERROR_NONE)
1582         {
1583             ERR("_cal_ipc_unmarshal_list fail");
1584             goto ERROR_RETURN;
1585         }
1586         ret = _cal_ipc_unmarshal_int(indata, &count);
1587         if (ret != CALENDAR_ERROR_NONE)
1588         {
1589             ERR("_cal_ipc_unmarshal_int fail");
1590             goto ERROR_RETURN;
1591         }
1592         if (count <= 0)
1593         {
1594             goto ERROR_RETURN;
1595         }
1596         ids = (int*)malloc(sizeof(int) * count);
1597         for(i = 0; i < count; i++)
1598         {
1599             ret = _cal_ipc_unmarshal_int(indata,&ids[i]);
1600             if (ret != CALENDAR_ERROR_NONE)
1601             {
1602                 ERR("_cal_ipc_unmarshal_int fail");
1603                 goto ERROR_RETURN;
1604             }
1605         }
1606     }
1607     else
1608     {
1609         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1610         ERR("_cal_server_ipc_db_insert_record fail");
1611         goto ERROR_RETURN;
1612     }
1613
1614     ret = calendar_db_replace_records(list, ids, count);
1615
1616     if (outdata)
1617     {
1618         *outdata = pims_ipc_data_create(0);
1619         if (!*outdata)
1620         {
1621             ERR("pims_ipc_data_create fail");
1622             goto DATA_FREE;
1623         }
1624         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1625         {
1626             pims_ipc_data_destroy(*outdata);
1627             *outdata = NULL;
1628             ERR("pims_ipc_data_put fail");
1629             goto DATA_FREE;
1630         }
1631         if (ret == CALENDAR_ERROR_NONE)
1632         {
1633             int transaction_ver = _cal_db_util_get_transaction_ver();
1634             if (_cal_ipc_marshal_int(transaction_ver,*outdata) != CALENDAR_ERROR_NONE)
1635             {
1636                 pims_ipc_data_destroy(*outdata);
1637                 *outdata = NULL;
1638                 ERR("_cal_ipc_marshal fail");
1639                 ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1640                 goto DATA_FREE;
1641             }
1642         }
1643     }
1644     else
1645     {
1646         ERR("outdata is NULL");
1647     }
1648     goto DATA_FREE;
1649
1650 ERROR_RETURN:
1651     if (outdata)
1652     {
1653         *outdata = pims_ipc_data_create(0);
1654         if (!*outdata)
1655         {
1656             ERR("pims_ipc_data_create fail");
1657             goto DATA_FREE;
1658         }
1659         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1660         {
1661             pims_ipc_data_destroy(*outdata);
1662             *outdata = NULL;
1663             ERR("pims_ipc_data_put fail");
1664             goto DATA_FREE;
1665         }
1666     }
1667     else
1668     {
1669         ERR("outdata is NULL");
1670     }
1671 DATA_FREE:
1672     CAL_FREE(ids);
1673     if (list)
1674     {
1675         calendar_list_destroy(list,true);
1676     }
1677     return;
1678 }
1679
1680 void _cal_server_ipc_db_register_reminder(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1681 {
1682     int ret = CALENDAR_ERROR_NONE;
1683         char *pkgname;
1684         char *extra_data_key;
1685         char *extra_data_value;
1686
1687         if (indata)
1688     {
1689         ret = _cal_ipc_unmarshal_char(indata, &pkgname);
1690         if (ret != CALENDAR_ERROR_NONE)
1691         {
1692             ERR("unmarshal fail");
1693             goto ERROR_RETURN;
1694         }
1695                 ret = _cal_ipc_unmarshal_char(indata, &extra_data_key);
1696         if (ret != CALENDAR_ERROR_NONE)
1697         {
1698             ERR("unmarshal fail");
1699             goto ERROR_RETURN;
1700         }
1701                 ret = _cal_ipc_unmarshal_char(indata, &extra_data_value);
1702         if (ret != CALENDAR_ERROR_NONE)
1703         {
1704             ERR("unmarshal fail");
1705             goto ERROR_RETURN;
1706         }
1707     }
1708     else
1709     {
1710         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1711         ERR("db_insert_vcalendars fail.");
1712         goto ERROR_RETURN;
1713     }
1714
1715         ret = calendar_reminder_add_receiver(pkgname, extra_data_key, extra_data_value);
1716     if (ret != CALENDAR_ERROR_NONE)
1717     {
1718         ERR("calendar_reminder_add_receiver() fail");
1719         goto ERROR_RETURN;
1720     }
1721
1722 ERROR_RETURN:
1723     if (outdata)
1724     {
1725         *outdata = pims_ipc_data_create(0);
1726         if (!*outdata)
1727         {
1728             ERR("pims_ipc_data_create fail");
1729                         return;
1730         }
1731         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1732         {
1733             pims_ipc_data_destroy(*outdata);
1734             *outdata = NULL;
1735             ERR("pims_ipc_data_put fail");
1736                         return;
1737         }
1738     }
1739     else
1740     {
1741         ERR("outdata is NULL");
1742     }
1743     return;
1744 }
1745
1746 void _cal_server_ipc_db_unregister_reminder(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1747 {
1748     int ret = CALENDAR_ERROR_NONE;
1749         char *pkgname;
1750
1751         if (indata)
1752     {
1753         ret = _cal_ipc_unmarshal_char(indata, &pkgname);
1754         if (ret != CALENDAR_ERROR_NONE)
1755         {
1756             ERR("unmarshal fail");
1757             goto ERROR_RETURN;
1758         }
1759     }
1760     else
1761     {
1762         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1763         ERR("db_insert_vcalendars fail.");
1764         goto ERROR_RETURN;
1765     }
1766
1767         ret = calendar_reminder_remove_receiver(pkgname);
1768     if (ret != CALENDAR_ERROR_NONE)
1769     {
1770         ERR("calendar_reminder_remove_receiver() fail");
1771         goto ERROR_RETURN;
1772     }
1773
1774 ERROR_RETURN:
1775     if (outdata)
1776     {
1777         *outdata = pims_ipc_data_create(0);
1778         if (!*outdata)
1779         {
1780             ERR("pims_ipc_data_create fail");
1781                         return;
1782         }
1783         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1784         {
1785             pims_ipc_data_destroy(*outdata);
1786             *outdata = NULL;
1787             ERR("pims_ipc_data_put fail");
1788                         return;
1789         }
1790     }
1791     else
1792     {
1793         ERR("outdata is NULL");
1794     }
1795     return;
1796 }
1797
1798 void _cal_server_ipc_db_activate_reminder(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1799 {
1800     int ret = CALENDAR_ERROR_NONE;
1801         char *pkgname;
1802
1803         if (indata)
1804     {
1805         ret = _cal_ipc_unmarshal_char(indata, &pkgname);
1806         if (ret != CALENDAR_ERROR_NONE)
1807         {
1808             ERR("unmarshal fail");
1809             goto ERROR_RETURN;
1810         }
1811     }
1812     else
1813     {
1814         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1815         ERR("db_insert_vcalendars fail.");
1816         goto ERROR_RETURN;
1817     }
1818
1819         ret = calendar_reminder_activate_receiver(pkgname);
1820     if (ret != CALENDAR_ERROR_NONE)
1821     {
1822         ERR("calendar_reminder_activate_receiver() fail");
1823         goto ERROR_RETURN;
1824     }
1825
1826 ERROR_RETURN:
1827     if (outdata)
1828     {
1829         *outdata = pims_ipc_data_create(0);
1830         if (!*outdata)
1831         {
1832             ERR("pims_ipc_data_create fail");
1833                         return;
1834         }
1835         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1836         {
1837             pims_ipc_data_destroy(*outdata);
1838             *outdata = NULL;
1839             ERR("pims_ipc_data_put fail");
1840                         return;
1841         }
1842     }
1843     else
1844     {
1845         ERR("outdata is NULL");
1846     }
1847     return;
1848 }
1849
1850 void _cal_server_ipc_db_deactivate_reminder(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1851 {
1852     int ret = CALENDAR_ERROR_NONE;
1853         char *pkgname;
1854
1855         if (indata)
1856     {
1857         ret = _cal_ipc_unmarshal_char(indata, &pkgname);
1858         if (ret != CALENDAR_ERROR_NONE)
1859         {
1860             ERR("unmarshal fail");
1861             goto ERROR_RETURN;
1862         }
1863     }
1864     else
1865     {
1866         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1867         ERR("db_insert_vcalendars fail.");
1868         goto ERROR_RETURN;
1869     }
1870
1871         ret = calendar_reminder_deactivate_receiver(pkgname);
1872     if (ret != CALENDAR_ERROR_NONE)
1873     {
1874         ERR("calendar_reminder_deactivate_pkgname() fail");
1875         goto ERROR_RETURN;
1876     }
1877
1878 ERROR_RETURN:
1879     if (outdata)
1880     {
1881         *outdata = pims_ipc_data_create(0);
1882         if (!*outdata)
1883         {
1884             ERR("pims_ipc_data_create fail");
1885                         return;
1886         }
1887         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1888         {
1889             pims_ipc_data_destroy(*outdata);
1890             *outdata = NULL;
1891             ERR("pims_ipc_data_put fail");
1892                         return;
1893         }
1894     }
1895     else
1896     {
1897         ERR("outdata is NULL");
1898     }
1899     return;
1900 }
1901
1902 void _cal_server_ipc_db_has_reminder(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
1903 {
1904     int ret = CALENDAR_ERROR_NONE;
1905         char *pkgname;
1906
1907         if (indata)
1908     {
1909         ret = _cal_ipc_unmarshal_char(indata, &pkgname);
1910         if (ret != CALENDAR_ERROR_NONE)
1911         {
1912             ERR("unmarshal fail");
1913             goto ERROR_RETURN;
1914         }
1915     }
1916     else
1917     {
1918         ret = CALENDAR_ERROR_INVALID_PARAMETER;
1919         ERR("db_insert_vcalendars fail.");
1920         goto ERROR_RETURN;
1921     }
1922
1923         ret = calendar_reminder_has_receiver(pkgname);
1924     if (ret != CALENDAR_ERROR_NONE)
1925     {
1926         ERR("calendar_reminder_deactivate_pkgname() fail");
1927         goto ERROR_RETURN;
1928     }
1929
1930 ERROR_RETURN:
1931     if (outdata)
1932     {
1933         *outdata = pims_ipc_data_create(0);
1934         if (!*outdata)
1935         {
1936             ERR("pims_ipc_data_create fail");
1937                         return;
1938         }
1939         if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0)
1940         {
1941             pims_ipc_data_destroy(*outdata);
1942             *outdata = NULL;
1943             ERR("pims_ipc_data_put fail");
1944                         return;
1945         }
1946     }
1947     else
1948     {
1949         ERR("outdata is NULL");
1950     }
1951     return;
1952 }
1953