src/framework/data-adapter/interface_item.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <pthread.h>
  19 #include <glib.h>
  20 #include <glib/gprintf.h>
  21
  22 #include "utility/sync_util.h"
  23 #include "data-adapter/agent_handler_manager.h"
  24 #include "data-adapter/agent_handler_manager_internal.h"
  25 #include "data-adapter/agent.h"
  26
  27 #include "data-adapter/interface_item.h"
  28 #include "data-adapter/changelog.h"
  29
  30 #ifndef EXPORT_API
  31 #define EXPORT_API __attribute__ ((visibility("default")))
  32 #endif
  33
  34 #ifndef SYNC_AGENT_LOG
  35 #undef LOG_TAG
  36 #define LOG_TAG "AF_DACI"
  37 #endif
  38
  39 EXPORT_API sync_agent_da_return_e sync_agent_create_item(sync_agent_da_item_s ** sync_agent_item)
  40 {
  41         _EXTERN_FUNC_ENTER;
  42
  43         *sync_agent_item = (sync_agent_da_item_s *) calloc(1, sizeof(sync_agent_da_item_s));
  44         if (*sync_agent_item == NULL) {
  45                 _DEBUG_ERROR("calloc failed !!");
  46                 return SYNC_AGENT_DA_ERRORS;
  47         }
  48
  49         _EXTERN_FUNC_EXIT;
  50         return SYNC_AGENT_DA_SUCCESS;
  51 }
  52
  53 EXPORT_API sync_agent_da_return_e sync_agent_add_item(sync_agent_da_item_s * sync_agent_item, char **item_id, int use_changelog)
  54 {
  55         _EXTERN_FUNC_ENTER;
  56         retvm_if(sync_agent_item == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_s is NULL !!");
  57
  58         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
  59         if (use_changelog == 1) {
  60                 ret = sync_agent_changelog_add_item_new(sync_agent_item, item_id);
  61                 if (ret != SYNC_AGENT_DA_SUCCESS) {
  62                         _DEBUG_ERROR("sync_agent_changelog_add_item_new() failed !!");
  63                 }
  64         } else {
  65                 ret = sync_agent_add_item_new(sync_agent_item, 1, item_id);
  66                 if (ret != SYNC_AGENT_DA_SUCCESS) {
  67                         _DEBUG_ERROR("sync_agent_add_item_new() failed !!");
  68                 }
  69         }
  70
  71         _EXTERN_FUNC_EXIT;
  72         return ret;
  73 }
  74
  75 EXPORT_API sync_agent_da_return_e sync_agent_add_bulk_item(sync_agent_da_item_s * sync_agent_item, char **item_id, int use_changelog)
  76 {
  77         _EXTERN_FUNC_ENTER;
  78
  79         retvm_if(sync_agent_item == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_s is NULL !!");
  80
  81         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
  82
  83         if (use_changelog == 1) {
  84                 ret = sync_agent_changelog_add_item_new(sync_agent_item, item_id);
  85                 if (ret != SYNC_AGENT_DA_SUCCESS) {
  86                         _DEBUG_ERROR("sync_agent_changelog_add_item_new() failed !!");
  87                 }
  88         } else {
  89                 ret = sync_agent_add_item_new(sync_agent_item, 1, item_id);
  90                 if (ret != SYNC_AGENT_DA_SUCCESS) {
  91                         _DEBUG_ERROR("sync_agent_add_item_new() failed !!");
  92                 }
  93         }
  94
  95         _EXTERN_FUNC_EXIT;
  96         return ret;
  97 }
  98
  99 EXPORT_API sync_agent_da_return_e sync_agent_update_item(char *item_id, int use_changelog)
 100 {
 101         _EXTERN_FUNC_ENTER;
 102
 103         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 104
 105         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 106         sync_agent_da_item_s *get_item = NULL;
 107
 108         if (use_changelog == 1) {
 109                 ret = sync_agent_create_item(&get_item);
 110                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 111                         _DEBUG_ERROR("sync_agent_create_item() failed !!");
 112                         return ret;
 113                 }
 114
 115                 ret = sync_agent_get_item(item_id, &get_item);
 116                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 117                         _DEBUG_ERROR("sync_agent_get_item() failed !!");
 118                         int ret_temp = sync_agent_free_item(get_item);
 119                         if (ret_temp != SYNC_AGENT_DA_SUCCESS) {
 120                                 _DEBUG_ERROR("sync_agent_free_item() failed !!");
 121                         }
 122                         return ret;
 123                 }
 124
 125                 ret = sync_agent_changelog_update_item_new(get_item->account_id, item_id);
 126                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 127                         _DEBUG_ERROR("sync_agent_changelog_update_item_new() failed !!");
 128                 }
 129
 130                 ret = sync_agent_free_item(get_item);
 131                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 132                         _DEBUG_ERROR("sync_agent_free_item() failed !!");
 133                 }
 134         } else {
 135                 ret = SYNC_AGENT_DA_SUCCESS;
 136         }
 137
 138         _EXTERN_FUNC_EXIT;
 139
 140         return ret;
 141 }
 142
 143 EXPORT_API sync_agent_da_return_e sync_agent_delete_item(char *item_id, int use_changelog)
 144 {
 145         _EXTERN_FUNC_ENTER;
 146
 147         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 148
 149         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 150         sync_agent_da_item_s *get_item = NULL;
 151
 152         if (use_changelog == 1) {
 153                 ret = sync_agent_create_item(&get_item);
 154                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 155                         _DEBUG_ERROR("sync_agent_create_item() failed, ret[%d]", ret);
 156                         return ret;
 157                 }
 158
 159                 ret = sync_agent_get_item_account_id(item_id, &get_item);
 160                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 161                         _DEBUG_ERROR("sync_agent_get_item_account_id() failed, ret[%d]", ret);
 162                         int ret_temp = sync_agent_free_item(get_item);
 163                         if (ret_temp != SYNC_AGENT_DA_SUCCESS) {
 164                                 _DEBUG_ERROR("sync_agent_get_item_account_id() failed, ret[%d]", ret);
 165                         }
 166                         return ret;
 167                 }
 168
 169                 ret = sync_agent_changelog_delete_item_new(get_item->account_id, item_id);
 170                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 171                         _DEBUG_ERROR("da_changelog_delete_item_internal() failed, ret[%d]", ret);
 172                 }
 173
 174                 ret = sync_agent_free_item(get_item);
 175                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 176                         _DEBUG_ERROR("sync_agent_free_item() failed, ret[%d]", ret);
 177                 }
 178         } else {
 179                 ret = da_delete_item_by_item_id_internal(item_id);
 180                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 181                         _DEBUG_ERROR("da_delete_item_by_item_id_internal() failed, ret[%d]", ret);
 182                 }
 183         }
 184
 185         _EXTERN_FUNC_EXIT;
 186
 187         return ret;
 188 }
 189
 190 EXPORT_API sync_agent_da_return_e sync_agent_query_delete_item(sync_agent_da_delete_item_query_s * query)
 191 {
 192         _EXTERN_FUNC_ENTER;
 193
 194         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_delete_item_query_s is NULL !!");
 195
 196         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 197
 198         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 199         if (daci_handler == NULL) {
 200                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 201                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 202         }
 203
 204         switch (query->option) {
 205         case SYNC_AGENT_DA_DELETE_ITEM_OPTION_ITEM_TYPE_ID:
 206                 ret = da_delete_item_by_item_type_id_new(daci_handler, query->account_id, query->item_type_id);
 207                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 208                         _DEBUG_ERROR("da_delete_item_by_item_type_id() failed !!");
 209                 }
 210                 break;
 211         default:
 212                 break;
 213         }
 214
 215         _EXTERN_FUNC_EXIT;
 216
 217         return ret;
 218 }
 219
 220 EXPORT_API sync_agent_da_return_e sync_agent_get_item(char *item_id, sync_agent_da_item_s ** sync_agent_item)
 221 {
 222         _EXTERN_FUNC_ENTER;
 223
 224         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 225
 226         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 227
 228         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 229         if (daci_handler == NULL) {
 230                 _DEBUG_ERROR("[%s] no handler for key");
 231                 return ret;
 232         }
 233
 234         ret = da_get_item_new(daci_handler, item_id, sync_agent_item);
 235         if (ret != SYNC_AGENT_DA_SUCCESS) {
 236                 _DEBUG_ERROR("da_get_item() faied !!");
 237         }
 238
 239         _EXTERN_FUNC_EXIT;
 240
 241         return ret;
 242 }
 243
 244 EXPORT_API sync_agent_da_return_e sync_agent_get_item_data_store_id(char *item_id, sync_agent_da_item_s ** sync_agent_item)
 245 {
 246         _EXTERN_FUNC_ENTER;
 247
 248         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 249
 250         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 251
 252         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 253         if (daci_handler == NULL) {
 254                 _DEBUG_ERROR("[%s] no handler for key");
 255                 return ret;
 256         }
 257
 258         ret = da_get_item_data_store_id_new(daci_handler, item_id, sync_agent_item);
 259         if (ret != SYNC_AGENT_DA_SUCCESS) {
 260                 _DEBUG_ERROR("da_get_item_data_store_id_new() faied, ret[%d]", ret);
 261         }
 262
 263         _EXTERN_FUNC_EXIT;
 264         return ret;
 265 }
 266
 267 EXPORT_API sync_agent_da_return_e sync_agent_get_item_account_id(char *item_id, sync_agent_da_item_s ** sync_agent_item)
 268 {
 269         _EXTERN_FUNC_ENTER;
 270
 271         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 272
 273         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 274
 275         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 276         if (daci_handler == NULL) {
 277                 _DEBUG_ERROR("[%s] no handler for key");
 278                 return ret;
 279         }
 280
 281         ret = da_get_item_account_id_new(daci_handler, item_id, sync_agent_item);
 282         if (ret != SYNC_AGENT_DA_SUCCESS) {
 283                 _DEBUG_ERROR("da_get_item_account_id_new() faied, ret[%d]", ret);
 284         }
 285
 286         _EXTERN_FUNC_EXIT;
 287         return ret;
 288 }
 289
 290 EXPORT_API sync_agent_da_return_e sync_agent_get_item_list(int account_id, sync_agent_da_get_item_list_query_s * query, GList ** list)
 291 {
 292         _EXTERN_FUNC_ENTER;
 293
 294         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_get_item_list_query_s is NULL !!");
 295
 296         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 297
 298         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 299         if (daci_handler == NULL) {
 300                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 301                 return ret;
 302         }
 303
 304         switch (query->option) {
 305         case SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_ACCOUNT_ID:
 306                 ret = da_get_item_by_account_id_new(daci_handler, account_id, query->item_type_id, list);
 307                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 308                         _DEBUG_ERROR("da_get_item_by_account_id() failed !!");
 309                 }
 310                 break;
 311         case SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_SERVICE_ID_MAPPING:
 312                 retvm_if(query->item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 313
 314                 ret = da_get_item_mapping_service_id_new(daci_handler, account_id, query->item_id, list);
 315                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 316                         _DEBUG_ERROR("da_get_item_mapping_service_id() failed !!");
 317                 }
 318                 break;
 319         default:
 320                 break;
 321         }
 322
 323         _EXTERN_FUNC_EXIT;
 324
 325         return ret;
 326 }
 327
 328 EXPORT_API sync_agent_da_return_e sync_agent_get_item_id(sync_agent_da_get_item_id_query_s * query, char **item_id)
 329 {
 330         _EXTERN_FUNC_ENTER;
 331
 332         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_get_item_id_query_s is NULL !!");
 333         retvm_if(query->service_id == NULL, SYNC_AGENT_DA_ERRORS, "service id is NULL !!");
 334
 335         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 336
 337         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 338         if (daci_handler == NULL) {
 339                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 340                 return ret;
 341         }
 342
 343         ret = da_get_item_item_id_new(daci_handler, query->account_id, query->service_id, query->item_type_id, item_id);
 344         if (ret != SYNC_AGENT_DA_SUCCESS) {
 345                 _DEBUG_ERROR("da_get_item_item_id_new() failed !!");
 346         }
 347
 348         _EXTERN_FUNC_EXIT;
 349
 350         return ret;
 351 }
 352
 353 EXPORT_API sync_agent_da_return_e sync_agent_get_item_id_list(sync_agent_da_get_item_id_list_query_s * query, GList ** list)
 354 {
 355         _EXTERN_FUNC_ENTER;
 356
 357         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_get_item_id_list_query_s is NULL !!");
 358
 359         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 360
 361         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 362         if (daci_handler == NULL) {
 363                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 364                 return ret;
 365         }
 366
 367         switch (query->option) {
 368         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_COLUMN_NAME:
 369                 retvm_if(query->folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
 370
 371                 ret = da_get_item_id_list_new(daci_handler, query->folder_id, query->column_name, list);
 372                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 373                         _DEBUG_ERROR("da_get_item_id_list_new() failed !!");
 374                 }
 375                 break;
 376         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_OPERATION_ID:
 377                 ret = da_get_item_id_list_by_operation_id_new(daci_handler, query->account_id, query->item_type_id, query->operation_id, list);
 378                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 379                         _DEBUG_ERROR("da_get_item_id_list_by_operation_id_new() failed !!");
 380                 }
 381                 break;
 382         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_OPERATION_ID_N_FOLDER_ID:
 383                 retvm_if(query->folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
 384
 385                 ret = da_get_item_id_list_by_operation_id_and_folder_id_new(daci_handler, query->account_id, query->folder_id, query->item_type_id, query->operation_id, list);
 386                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 387                         _DEBUG_ERROR("da_get_item_id_list_by_operation_id_and_folder_id_new() failed !!");
 388                 }
 389                 break;
 390         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_OPERATION_ID_N_ITEM_TYPE_ID:
 391                 ret = da_get_item_info_by_item_type_id_and_operation_id_new(daci_handler, query->account_id, query->item_type_id, query->operation_id, list);
 392                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 393                         _DEBUG_ERROR("da_get_item_info_by_item_type_id_and_operation_id_new() failed !!");
 394                 }
 395                 break;
 396         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_ITEM_TYPE_ID:
 397                 ret = da_get_item_id_list_by_datastore_id_new(daci_handler, query->item_type_id, list);
 398                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 399                         _DEBUG_ERROR("da_get_item_id_list_by_datastore_id_new() failed !!");
 400                 }
 401                 break;
 402         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_ITEM_TYPE_ID_N_ACCOUNT_ID:
 403                 ret = da_get_item_id_list_by_datastore_id_with_account_id_new(daci_handler, query->account_id, query->item_type_id, list);
 404                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 405                         _DEBUG_ERROR("da_get_item_id_list_by_datastore_id_with_account_id_new() failed !!");
 406                 }
 407                 break;
 408         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_FOLDER_ID_N_ACCOUNT_ID:
 409                 retvm_if(query->folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
 410
 411                 ret = da_get_item_id_list_by_folder_id_and_account_id(daci_handler, query->account_id, query->folder_id, list);
 412                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 413                         _DEBUG_ERROR("da_get_item_id_list_by_folder_id_and_account_id() failed !!");
 414                 }
 415                 break;
 416         default:
 417                 break;
 418         }
 419
 420         _EXTERN_FUNC_EXIT;
 421
 422         return ret;
 423 }
 424
 425 EXPORT_API sync_agent_da_return_e sync_agent_free_item(sync_agent_da_item_s * sync_agent_item)
 426 {
 427         _EXTERN_FUNC_ENTER;
 428
 429         if (sync_agent_item != NULL) {
 430                 if (sync_agent_item->item_id != NULL)
 431                         free(sync_agent_item->item_id);
 432                 sync_agent_item->item_id = NULL;
 433
 434                 if (sync_agent_item->folder_id != NULL)
 435                         free(sync_agent_item->folder_id);
 436                 sync_agent_item->folder_id = NULL;
 437
 438                 if (sync_agent_item->service_id != NULL)
 439                         free(sync_agent_item->service_id);
 440                 sync_agent_item->service_id = NULL;
 441
 442                 if (sync_agent_item->parent_service_id != NULL)
 443                         free(sync_agent_item->parent_service_id);
 444                 sync_agent_item->parent_service_id = NULL;
 445
 446                 if (sync_agent_item->access_name != NULL)
 447                         free(sync_agent_item->access_name);
 448                 sync_agent_item->access_name = NULL;
 449
 450                 free(sync_agent_item);
 451                 sync_agent_item = NULL;
 452         } else {
 453                 _DEBUG_ERROR("sync_agent_item is NULL !!");
 454                 return SYNC_AGENT_DA_ERRORS;
 455         }
 456         _EXTERN_FUNC_EXIT;
 457         return SYNC_AGENT_DA_SUCCESS;
 458 }
 459
 460 EXPORT_API sync_agent_da_return_e sync_agent_free_item_list(GList * list)
 461 {
 462         _EXTERN_FUNC_ENTER;
 463
 464         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 465
 466         if (list != NULL) {
 467                 GList *iter = NULL;
 468                 sync_agent_da_item_s *iter_data;
 469
 470                 for (iter = list; iter != NULL;) {
 471                         iter_data = NULL;
 472                         iter_data = (sync_agent_da_item_s *) (iter->data);
 473
 474                         iter = g_list_next(iter);
 475                         list = g_list_remove(list, iter_data);
 476
 477                         ret = sync_agent_free_item(iter_data);
 478                         if (ret != SYNC_AGENT_DA_SUCCESS) {
 479                                 _DEBUG_ERROR("sync_agent_free_item() failed !!");
 480                                 return ret;
 481                         }
 482                 }
 483
 484                 g_list_free(list);
 485         } else {
 486                 _DEBUG_ERROR("list is NULL !!");
 487                 return SYNC_AGENT_DA_ERRORS;
 488         }
 489         _EXTERN_FUNC_EXIT;
 490         return ret;
 491 }
 492
 493 EXPORT_API sync_agent_da_return_e sync_agent_free_item_id(char *item_id)
 494 {
 495         _EXTERN_FUNC_ENTER;
 496
 497         if (item_id != NULL) {
 498                 free(item_id);
 499                 item_id = NULL;
 500         } else {
 501                 _DEBUG_ERROR("item id is NULL !!");
 502                 return SYNC_AGENT_DA_ERRORS;;
 503         }
 504
 505         _EXTERN_FUNC_EXIT;
 506         return SYNC_AGENT_DA_SUCCESS;
 507 }
 508
 509 EXPORT_API sync_agent_da_return_e sync_agent_free_item_id_list(GList * list)
 510 {
 511         _EXTERN_FUNC_ENTER;
 512
 513         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 514
 515         if (list != NULL) {
 516                 GList *iter = NULL;
 517                 char *iter_data;
 518
 519                 for (iter = list; iter != NULL;) {
 520                         iter_data = NULL;
 521                         iter_data = (char *)(iter->data);
 522
 523                         iter = g_list_next(iter);
 524                         list = g_list_remove(list, iter_data);
 525
 526                         ret = sync_agent_free_item_id(iter_data);
 527                         if (ret != SYNC_AGENT_DA_SUCCESS) {
 528                                 _DEBUG_ERROR("sync_agent_free_item_id() failed !!");
 529                                 return ret;
 530                         }
 531                 }
 532                 g_list_free(list);
 533         } else {
 534                 _DEBUG_INFO("list is NULL !!");
 535                 return ret;
 536         }
 537         _EXTERN_FUNC_EXIT;
 538         return ret;
 539 }
 540
 541 EXPORT_API sync_agent_da_return_e sync_agent_get_item_count(int data_store_id, int *item_count)
 542 {
 543         _EXTERN_FUNC_ENTER;
 544
 545         retvm_if(item_count == NULL, SYNC_AGENT_DA_ERRORS, "*item_count is NULL !!");
 546
 547         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 548         int total_count = 0;
 549         GList *account_info_list = NULL;
 550
 551         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 552         if (daci_handler == NULL) {
 553                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 554                 ret = SYNC_AGENT_DA_ERRORS;
 555                 goto return_part;
 556         }
 557
 558         sync_agent_fw_account_query_s account_query;
 559         account_query.query = ACCOUNT_QUERY_BY_SERVICE_TYPE;
 560         account_query.service_type = data_store_id;
 561         sync_agent_acc_error_e acc_err = sync_agent_query_fw_account(&account_query, &account_info_list);
 562         if (acc_err != SYNC_AGENT_ACC_SUCCESS) {
 563                 _DEBUG_ERROR("sync_agent_query_fw_account is failed");
 564                 ret = SYNC_AGENT_DA_ERRORS;
 565                 goto return_part;
 566         }
 567
 568         GList *account_iter = NULL;
 569         for (account_iter = account_info_list; account_iter != NULL; account_iter = g_list_next(account_iter)) {
 570                 sync_agent_fw_account_s *fw_account = (sync_agent_fw_account_s *)account_iter->data;
 571                 int fw_account_id = fw_account->account_id;
 572                 int temp_count = 0;
 573
 574                 ret = da_get_item_count_by_datastore_id(daci_handler, data_store_id, fw_account_id, &temp_count);
 575                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 576                         _DEBUG_ERROR("da_get_item_count_by_datastore_id() failed !!");
 577                 }
 578                 total_count += temp_count;
 579         }
 580
 581 return_part:
 582         *item_count = total_count;
 583         _DEBUG_INFO("item_count = %d", *item_count);
 584
 585         if(account_info_list != NULL) {
 586                 sync_agent_free_fw_account_list(account_info_list);
 587                 account_info_list = NULL;
 588         }
 589         _EXTERN_FUNC_EXIT;
 590         return ret;
 591 }
 592
 593 EXPORT_API sync_agent_da_return_e sync_agent_get_updated_exdate_item_id_list(char *fw_id, GList ** list)
 594 {
 595         _EXTERN_FUNC_ENTER;
 596         retvm_if(fw_id == NULL, SYNC_AGENT_DA_ERRORS, "fw_id is NULL !!");
 597         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 598
 599         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 600         goto_if(daci_handler == NULL, "daci_handler is null");
 601
 602         ret = da_get_updated_exdate_item_id_list(daci_handler, fw_id, list);
 603         goto_if(ret != SYNC_AGENT_DA_SUCCESS, "da_get_updated_exdate_item_id_list() failed, ret = [%d]", ret);
 604
 605 return_part:
 606         _EXTERN_FUNC_EXIT;
 607         return ret;
 608 }