src/agent/common/common_define.c

   1 /*
   2  * oma-ds-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 /**
  19  *   @Common_Define_Internal.c
  20  *   @version                                                                   0.1
  21  *   @brief                                                                             This file is the source file of implementation of defined Common structure
  22  */
  23
  24 #include <sync_agent.h>
  25
  26 #include "common/common_define.h"
  27
  28 #ifndef OMADS_AGENT_LOG
  29 #undef LOG_TAG
  30 #define LOG_TAG "OMA_DS_COMMON"
  31 #endif
  32
  33 datastore_s *datastoreinfo_per_content_type[4];
  34
  35 datastore_info_s *create_datastore_info(char *target, char *source)
  36 {
  37         _EXTERN_FUNC_ENTER;
  38
  39         datastore_info_s *datastore_info = (datastore_info_s *) calloc(1, sizeof(datastore_info_s));
  40         retvm_if(datastore_info == NULL, NULL, "datastore_info is NULL");
  41
  42         if (target != NULL)
  43                 datastore_info->target = strdup(target);
  44         if (source != NULL)
  45                 datastore_info->source = strdup(source);
  46
  47         _EXTERN_FUNC_EXIT;
  48
  49         return datastore_info;
  50 }
  51
  52 void free_datastore_infos(GList * datastore_infos)
  53 {
  54         _EXTERN_FUNC_ENTER;
  55         retm_if(datastore_infos == NULL, "List is NULL");
  56
  57         GList *iter = NULL;
  58         for (iter = datastore_infos; iter != NULL; iter = g_list_next(iter))
  59                 free_datastore_info(iter->data);
  60
  61         g_list_free(datastore_infos);
  62
  63         _EXTERN_FUNC_EXIT;
  64 }
  65
  66 void free_datastore_info(datastore_info_s * datastore_info)
  67 {
  68         _EXTERN_FUNC_ENTER;
  69         retm_if(datastore_info == NULL, "pDatastoreInfo is NULL");
  70
  71         if (datastore_info->target != NULL) {
  72                 free(datastore_info->target);
  73                 datastore_info->target = NULL;
  74         }
  75
  76         if (datastore_info->source != NULL) {
  77                 free(datastore_info->source);
  78                 datastore_info->source = NULL;
  79         }
  80
  81         if (datastore_info->last_anchor != NULL) {
  82                 free(datastore_info->last_anchor);
  83                 datastore_info->last_anchor = NULL;
  84         }
  85
  86         if (datastore_info->next_anchor != NULL) {
  87                 free(datastore_info->next_anchor);
  88                 datastore_info->next_anchor = NULL;
  89         }
  90
  91         free(datastore_info);
  92
  93         _EXTERN_FUNC_EXIT;
  94 }
  95
  96 void set_datastore_info_sync_type(datastore_info_s * datastore_info, alert_type_e sync_type)
  97 {
  98         _EXTERN_FUNC_ENTER;
  99         if (datastore_info != NULL)
 100                 datastore_info->sync_type = sync_type;
 101
 102         _EXTERN_FUNC_EXIT;
 103 }
 104
 105 void set_datastore_info_last_anchor(datastore_info_s * datastore_info, char *last_anchor)
 106 {
 107         _EXTERN_FUNC_ENTER;
 108         if (datastore_info != NULL) {
 109                 if (last_anchor != NULL)
 110                         datastore_info->last_anchor = strdup(last_anchor);
 111         }
 112
 113         _EXTERN_FUNC_EXIT;
 114 }
 115
 116 void set_datastore_info_next_anchor(datastore_info_s * datastore_info, char *next_anchor)
 117 {
 118         _EXTERN_FUNC_ENTER;
 119         if (datastore_info != NULL) {
 120                 if (next_anchor != NULL)
 121                         datastore_info->next_anchor = strdup(next_anchor);
 122         }
 123
 124         _EXTERN_FUNC_EXIT;
 125 }
 126
 127 void set_datastore_info_max_obj_size(datastore_info_s * datastore_info, unsigned int max_obj_size)
 128 {
 129         _EXTERN_FUNC_ENTER;
 130         if (datastore_info != NULL)
 131                 datastore_info->max_obj_size = max_obj_size;
 132
 133         _EXTERN_FUNC_EXIT;
 134 }
 135
 136 changed_item_s *create_changed_item(change_type_e type, char *luid)
 137 {
 138         _EXTERN_FUNC_ENTER;
 139
 140         changed_item_s *changed_item = (changed_item_s *) calloc(1, sizeof(changed_item_s));
 141         retvm_if(changed_item == NULL, NULL, "changed_item is NULL");
 142
 143         changed_item->change_type = type;
 144
 145         if (luid != NULL)
 146                 changed_item->luid = strdup(luid);
 147
 148         changed_item->content_type = NULL;
 149
 150         _EXTERN_FUNC_EXIT;
 151
 152         return changed_item;
 153 }
 154
 155 void set_changed_item_content_type(changed_item_s * changed_item, char *content_type)
 156 {
 157         _EXTERN_FUNC_ENTER;
 158
 159         retm_if(changed_item == NULL, "pChangedItem is NULL");
 160
 161         if (content_type != NULL)
 162                 changed_item->content_type = strdup(content_type);
 163
 164         _EXTERN_FUNC_EXIT;
 165 }
 166
 167 void free_changed_item(changed_item_s * changed_item)
 168 {
 169         _EXTERN_FUNC_ENTER;
 170
 171         retm_if(changed_item == NULL, "pChangedItem is NULL");
 172
 173         if (changed_item->luid != NULL) {
 174                 free(changed_item->luid);
 175                 changed_item->luid = NULL;
 176         }
 177
 178         if (changed_item->content_type != NULL) {
 179                 free(changed_item->content_type);
 180                 changed_item->content_type = NULL;
 181         }
 182
 183         if (changed_item->data != NULL) {
 184                 free(changed_item->data);
 185                 changed_item->data = NULL;
 186         }
 187
 188         if (changed_item != NULL)
 189                 free(changed_item);
 190
 191         _EXTERN_FUNC_EXIT;
 192 }
 193
 194 void set_changed_item_data(changed_item_s * changed_item, char *data)
 195 {
 196         _EXTERN_FUNC_ENTER;
 197
 198         retm_if(changed_item == NULL, "pChangedItem is NULL");
 199
 200         if (data != NULL)
 201                 changed_item->data = strdup(data);
 202
 203         _EXTERN_FUNC_EXIT;
 204 }
 205
 206 void set_changed_item_index_of_datastore(changed_item_s * changed_item, unsigned int index_of_datastore)
 207 {
 208         _EXTERN_FUNC_ENTER;
 209
 210         retm_if(changed_item == NULL, "changed_item is NULL");
 211
 212         changed_item->index_of_datastore = index_of_datastore;
 213
 214         _EXTERN_FUNC_EXIT;
 215 }
 216
 217 changed_datastore_s *create_changed_datastore(char *source, char *target, int has_number_of_changes, unsigned int number_of_changes)
 218 {
 219         _EXTERN_FUNC_ENTER;
 220
 221         changed_datastore_s *changed_datastore = (changed_datastore_s *) calloc(1, sizeof(changed_datastore_s));
 222         retvm_if(changed_datastore == NULL, NULL, "changed_datastore is NULL");
 223
 224         if (source != NULL)
 225                 changed_datastore->source = strdup(source);
 226         if (target != NULL)
 227                 changed_datastore->target = strdup(target);
 228
 229         changed_datastore->need_sync_command = 1;
 230         changed_datastore->number_of_changes = number_of_changes;
 231         changed_datastore->has_number_of_changes = has_number_of_changes;
 232
 233         _EXTERN_FUNC_EXIT;
 234
 235         return changed_datastore;
 236 }
 237
 238 void free_changed_datastores(GList * changed_datastores)
 239 {
 240         _EXTERN_FUNC_ENTER;
 241
 242         retm_if(changed_datastores == NULL, "List is NULL");
 243
 244         GList *iter = NULL;
 245         for (iter = changed_datastores; iter != NULL; iter = g_list_next(iter))
 246                 free_changed_datastore(iter->data);
 247
 248         g_list_free(changed_datastores);
 249
 250         _EXTERN_FUNC_EXIT;
 251 }
 252
 253 void free_changed_datastore(changed_datastore_s * changed_datastore)
 254 {
 255         _EXTERN_FUNC_ENTER;
 256
 257         retm_if(changed_datastore == NULL, "pChangedDatastore is NULL");
 258
 259         if (changed_datastore->source != NULL) {
 260                 free(changed_datastore->source);
 261                 changed_datastore->source = NULL;
 262         }
 263
 264         if (changed_datastore->target != NULL) {
 265                 free(changed_datastore->target);
 266                 changed_datastore->target = NULL;
 267         }
 268
 269         GList *iter = NULL;
 270         for (iter = changed_datastore->change_item; iter != NULL; iter = g_list_next(iter))
 271                 free_changed_item(iter->data);
 272
 273         g_list_free(changed_datastore->change_item);
 274         changed_datastore->change_item = NULL;
 275
 276         for (iter = changed_datastore->sent_item; iter != NULL; iter = g_list_next(iter))
 277                 free_changed_item(iter->data);
 278
 279         g_list_free(changed_datastore->sent_item);
 280         changed_datastore->sent_item = NULL;
 281
 282         if (changed_datastore != NULL)
 283                 free(changed_datastore);
 284
 285         _EXTERN_FUNC_EXIT;
 286 }
 287
 288 void set_changed_datastore_changed_item(changed_datastore_s * changed_datastore, GList * changed_items)
 289 {
 290         _EXTERN_FUNC_ENTER;
 291
 292         if (changed_datastore != NULL)
 293                 changed_datastore->change_item = changed_items;
 294
 295         _EXTERN_FUNC_EXIT;
 296 }
 297
 298 void add_changed_datastore_changed_item(changed_datastore_s * changed_datastore, changed_item_s * changed_item)
 299 {
 300         _EXTERN_FUNC_ENTER;
 301
 302         retm_if(changed_datastore == NULL, "changed_datastore is NULL");
 303
 304         changed_datastore->change_item = g_list_append(changed_datastore->change_item, changed_item);
 305
 306         _EXTERN_FUNC_EXIT;
 307 }
 308
 309 applied_status_s *create_applied_status(char *luid, change_type_e change_type, int status)
 310 {
 311         _EXTERN_FUNC_ENTER;
 312
 313         applied_status_s *applied_status = (applied_status_s *) calloc(1, sizeof(applied_status_s));
 314         retvm_if(applied_status == NULL, NULL, "appliedStatus is NULL");
 315
 316         if (luid != NULL)
 317                 applied_status->luid = strdup(luid);
 318
 319         applied_status->change_type = change_type;
 320         applied_status->status = status;
 321
 322         _EXTERN_FUNC_EXIT;
 323
 324         return applied_status;
 325 }
 326
 327 void free_applied_statuses(GList * applied_statuses)
 328 {
 329         _EXTERN_FUNC_ENTER;
 330
 331         retm_if(applied_statuses == NULL, "List is NULL");
 332
 333         GList *iter = NULL;
 334         for (iter = applied_statuses; iter != NULL; iter = g_list_next(iter))
 335                 free_applied_status(iter->data);
 336
 337         g_list_free(applied_statuses);
 338
 339         _EXTERN_FUNC_EXIT;
 340 }
 341
 342 void free_applied_status(applied_status_s * applied_status)
 343 {
 344         _EXTERN_FUNC_ENTER;
 345
 346         retm_if(applied_status == NULL, "List is NULL");
 347
 348         if (applied_status->luid != NULL) {
 349                 free(applied_status->luid);
 350                 applied_status->luid = NULL;
 351         }
 352
 353         free(applied_status);
 354
 355         _EXTERN_FUNC_EXIT;
 356 }
 357
 358 sending_status_s *create_sending_status(char *source, char *target)
 359 {
 360         _EXTERN_FUNC_ENTER;
 361
 362         sending_status_s *sending_status = (sending_status_s *) calloc(1, sizeof(sending_status_s));
 363         retvm_if(sending_status == NULL, NULL, "sending_status is NULL");
 364
 365         if (source != NULL)
 366                 sending_status->source = strdup(source);
 367
 368         if (target != NULL)
 369                 sending_status->target = strdup(target);
 370
 371         _EXTERN_FUNC_EXIT;
 372
 373         return sending_status;
 374 }
 375
 376 void free_sending_statuses(GList * sending_statuses)
 377 {
 378         _EXTERN_FUNC_ENTER;
 379
 380         retm_if(sending_statuses == NULL, "List is NULL");
 381
 382         GList *iter = NULL;
 383         for (iter = sending_statuses; iter != NULL; iter = g_list_next(iter))
 384                 free_sending_status(iter->data);
 385
 386         g_list_free(sending_statuses);
 387
 388         _EXTERN_FUNC_EXIT;
 389 }
 390
 391 void free_sending_status(sending_status_s * sending_status)
 392 {
 393         _EXTERN_FUNC_ENTER;
 394
 395         retm_if(sending_status == NULL, "pSendingStatus is NULL");
 396
 397         if (sending_status->source != NULL) {
 398                 free(sending_status->source);
 399                 sending_status->source = NULL;
 400         }
 401
 402         if (sending_status->target != NULL) {
 403                 free(sending_status->target);
 404                 sending_status->target = NULL;
 405         }
 406
 407         GList *iter = NULL;
 408         for (iter = sending_status->items; iter != NULL; iter = g_list_next(iter))
 409                 free_applied_status(iter->data);
 410
 411         g_list_free(sending_status->items);
 412
 413         free(sending_status);
 414
 415         _EXTERN_FUNC_EXIT;
 416 }
 417
 418 void add_sending_status_applied_status(sending_status_s * sending_status, applied_status_s * applied_status)
 419 {
 420         _EXTERN_FUNC_ENTER;
 421
 422         retm_if(sending_status == NULL, "sending_status is NULL");
 423
 424         sending_status->items = g_list_append(sending_status->items, applied_status);
 425
 426         _EXTERN_FUNC_EXIT;
 427 }
 428
 429 datastore_s *create_datastore(char *target, char *source)
 430 {
 431         _EXTERN_FUNC_ENTER;
 432
 433         datastore_s *datastore = (datastore_s *) calloc(1, sizeof(datastore_s));
 434         retvm_if(datastore == NULL, NULL, "datastore is NULL");
 435
 436         if (target != NULL)
 437                 datastore->target = strdup(target);
 438
 439         if (source != NULL)
 440                 datastore->source = strdup(source);
 441
 442         _EXTERN_FUNC_EXIT;
 443
 444         return datastore;
 445 }
 446
 447 void set_datastore_content_type_info(datastore_s * datastore, int datastore_id, int folder_type_id)
 448 {
 449         _EXTERN_FUNC_ENTER;
 450
 451         if (datastore != NULL) {
 452                 datastore->datastore_id = datastore_id;
 453                 datastore->folder_type_id = folder_type_id;
 454         }
 455
 456         _EXTERN_FUNC_EXIT;
 457 }
 458
 459 void set_datastore_account_info(datastore_s * datastore, char *account_id, char *account_pw)
 460 {
 461         _EXTERN_FUNC_ENTER;
 462
 463         if (datastore != NULL) {
 464                 if (account_id != NULL)
 465                         datastore->id = strdup(account_id);
 466                 if (account_pw != NULL)
 467                         datastore->pw = strdup(account_pw);
 468         }
 469
 470         _EXTERN_FUNC_EXIT;
 471 }
 472
 473 void set_datastore_client_sync_type(datastore_s * datastore, alert_type_e sync_type)
 474 {
 475         _EXTERN_FUNC_ENTER;
 476
 477         if (datastore != NULL)
 478                 datastore->client_sync_type = sync_type;
 479
 480         _EXTERN_FUNC_EXIT;
 481 }
 482
 483 void set_datastore_server_sync_type(datastore_s * datastore, alert_type_e sync_type)
 484 {
 485         _EXTERN_FUNC_ENTER;
 486
 487         if (datastore != NULL)
 488                 datastore->server_sync_type = sync_type;
 489
 490         _EXTERN_FUNC_EXIT;
 491 }
 492
 493 void set_datastore_client_anchor(datastore_s * datastore, char *last_anchor, char *next_anchor)
 494 {
 495         _EXTERN_FUNC_ENTER;
 496
 497         if (datastore != NULL) {
 498                 if (last_anchor != NULL)
 499                         datastore->last_anchor_client = strdup(last_anchor);
 500                 if (next_anchor != NULL)
 501                         datastore->next_anchor_client = strdup(next_anchor);
 502         }
 503
 504         _EXTERN_FUNC_EXIT;
 505 }
 506
 507 void set_datastore_server_anchor(datastore_s * datastore, char *last_anchor, char *next_anchor)
 508 {
 509         _EXTERN_FUNC_ENTER;
 510
 511         if (datastore != NULL) {
 512                 if (last_anchor != NULL)
 513                         datastore->last_anchor_server = strdup(last_anchor);
 514                 if (next_anchor != NULL)
 515                         datastore->next_anchor_server = strdup(next_anchor);
 516         }
 517
 518         _EXTERN_FUNC_EXIT;
 519 }
 520
 521 sync_result_s *create_sync_result()
 522 {
 523         _EXTERN_FUNC_ENTER;
 524
 525         sync_result_s *syncResult = calloc(1, sizeof(sync_result_s));
 526         retvm_if(syncResult == NULL, NULL, "syncResult is NULL");
 527
 528         _EXTERN_FUNC_EXIT;
 529
 530         return syncResult;
 531 }
 532
 533 sync_result_s *dup_sync_result(sync_result_s * org_sync_result)
 534 {
 535         _EXTERN_FUNC_ENTER;
 536
 537         retvm_if(org_sync_result == NULL, NULL, "orgSyncResult is NULL");
 538
 539         sync_result_s *syn_cre_sult = calloc(1, sizeof(sync_result_s));
 540         retvm_if(syn_cre_sult == NULL, NULL, "syn_cre_sult is NULL");
 541
 542         syn_cre_sult->session_result = org_sync_result->session_result;
 543         syn_cre_sult->number_of_change = org_sync_result->number_of_change;
 544         syn_cre_sult->received_count = org_sync_result->received_count;
 545         syn_cre_sult->add_count = org_sync_result->add_count;
 546         syn_cre_sult->replace_count = org_sync_result->replace_count;
 547         syn_cre_sult->delete_count = org_sync_result->delete_count;
 548
 549         _EXTERN_FUNC_EXIT;
 550
 551         return syn_cre_sult;
 552
 553 }
 554
 555 void set_number_of_change(sync_result_s * sync_result, unsigned int number_of_change)
 556 {
 557         _EXTERN_FUNC_ENTER;
 558
 559         if (sync_result != NULL)
 560                 sync_result->number_of_change = number_of_change;
 561
 562         _EXTERN_FUNC_EXIT;
 563 }
 564
 565 void add_add_count(sync_result_s * sync_result, unsigned int add_cnt)
 566 {
 567         _EXTERN_FUNC_ENTER;
 568
 569         if (sync_result != NULL)
 570                 sync_result->add_count += add_cnt;
 571
 572         _EXTERN_FUNC_EXIT;
 573 }
 574
 575 void add_receive_count(sync_result_s * sync_result, unsigned int received_count)
 576 {
 577         _EXTERN_FUNC_ENTER;
 578
 579         if (sync_result != NULL)
 580                 sync_result->received_count += received_count;
 581
 582         _EXTERN_FUNC_EXIT;
 583 }
 584
 585 void add_replace_count(sync_result_s * sync_result, unsigned int replace_cnt)
 586 {
 587         _EXTERN_FUNC_ENTER;
 588
 589         if (sync_result != NULL)
 590                 sync_result->replace_count += replace_cnt;
 591
 592         _EXTERN_FUNC_EXIT;
 593 }
 594
 595 void add_delete_count(sync_result_s * sync_result, unsigned int delete_cnt)
 596 {
 597         _EXTERN_FUNC_ENTER;
 598
 599         if (sync_result != NULL)
 600                 sync_result->delete_count += delete_cnt;
 601
 602         _EXTERN_FUNC_EXIT;
 603 }
 604
 605 void free_pre_sync_return_obj(pre_sync_return_obj_s * pre_sync_return_obj)
 606 {
 607         _EXTERN_FUNC_ENTER;
 608
 609         retm_if(pre_sync_return_obj == NULL, "pre_sync_return_obj is NULL");
 610
 611         GList *iter = NULL;
 612         for (iter = pre_sync_return_obj->datastore_info; iter != NULL; iter = g_list_next(iter))
 613                 free_datastore_info(iter->data);
 614         g_list_free(pre_sync_return_obj->datastore_info);
 615         pre_sync_return_obj->datastore_info = NULL;
 616
 617         if (pre_sync_return_obj->dev_id != NULL) {
 618                 free(pre_sync_return_obj->dev_id);
 619                 pre_sync_return_obj->dev_id = NULL;
 620         }
 621
 622         free(pre_sync_return_obj);
 623         pre_sync_return_obj = NULL;
 624
 625         _EXTERN_FUNC_EXIT;
 626 }
 627
 628 void free_sync_obj(sync_obj_s * sync_obj)
 629 {
 630         _EXTERN_FUNC_ENTER;
 631
 632         retm_if(sync_obj == NULL, "sync_obj is NULL");
 633
 634         GList *iter = NULL;
 635         for (iter = sync_obj->changed_datastore; iter != NULL; iter = g_list_next(iter))
 636                 free_changed_datastore(iter->data);
 637         g_list_free(sync_obj->changed_datastore);
 638         sync_obj->changed_datastore = NULL;
 639
 640         for (iter = sync_obj->sending_status; iter != NULL; iter = g_list_next(iter))
 641                 free_sending_status(iter->data);
 642         g_list_free(sync_obj->sending_status);
 643         sync_obj->sending_status = NULL;
 644
 645         free(sync_obj);
 646         sync_obj = NULL;
 647
 648         _EXTERN_FUNC_EXIT;
 649 }
 650
 651 void free_sync_return_obj(sync_return_obj_s * sync_return_obj)
 652 {
 653         _EXTERN_FUNC_ENTER;
 654
 655         retm_if(sync_return_obj == NULL, "pSyncReturnObj is NULL");
 656
 657         GList *iter = NULL;
 658         for (iter = sync_return_obj->changed_datastore; iter != NULL; iter = g_list_next(iter))
 659                 free_changed_datastore(iter->data);
 660         g_list_free(sync_return_obj->changed_datastore);
 661         sync_return_obj->changed_datastore = NULL;
 662
 663         for (iter = sync_return_obj->status; iter != NULL; iter = g_list_next(iter))
 664                 free_applied_status(iter->data);
 665         g_list_free(sync_return_obj->status);
 666         sync_return_obj->status = NULL;
 667
 668         free(sync_return_obj);
 669         sync_return_obj = NULL;
 670
 671         _EXTERN_FUNC_EXIT;
 672 }
 673
 674 void free_datastore(datastore_s * datastore)
 675 {
 676         _EXTERN_FUNC_ENTER;
 677
 678         retm_if(datastore == NULL, "pDatastore is NULL");
 679
 680         if (datastore->target != NULL) {
 681                 free(datastore->target);
 682                 datastore->target = NULL;
 683         }
 684
 685         if (datastore->source != NULL) {
 686                 free(datastore->source);
 687                 datastore->source = NULL;
 688         }
 689
 690         if (datastore->id != NULL) {
 691                 free(datastore->id);
 692                 datastore->id = NULL;
 693         }
 694
 695         if (datastore->pw != NULL) {
 696                 free(datastore->pw);
 697                 datastore->pw = NULL;
 698         }
 699
 700         if (datastore->last_anchor_client != NULL) {
 701                 free(datastore->last_anchor_client);
 702                 datastore->last_anchor_client = NULL;
 703         }
 704
 705         if (datastore->next_anchor_client != NULL) {
 706                 free(datastore->next_anchor_client);
 707                 datastore->next_anchor_client = NULL;
 708         }
 709
 710         if (datastore->last_anchor_server != NULL) {
 711                 free(datastore->last_anchor_server);
 712                 datastore->last_anchor_server = NULL;
 713         }
 714
 715         if (datastore->next_anchor_server != NULL) {
 716                 free(datastore->next_anchor_server);
 717                 datastore->next_anchor_server = NULL;
 718         }
 719
 720         if (datastore->client_sync_result != NULL)
 721                 free(datastore->client_sync_result);
 722
 723         if (datastore->server_sync_result != NULL)
 724                 free(datastore->server_sync_result);
 725
 726         free(datastore);
 727
 728         _EXTERN_FUNC_EXIT;
 729 }
 730
 731 void free_sync_service(sync_service_s * category)
 732 {
 733         _EXTERN_FUNC_ENTER;
 734
 735         retm_if(category == NULL, "category is NULL");
 736
 737         if (category->src_uri != NULL)
 738                 free(category->src_uri);
 739
 740         if (category->tgt_uri != NULL)
 741                 free(category->tgt_uri);
 742
 743         if (category->id != NULL)
 744                 free(category->id);
 745
 746         if (category->password != NULL)
 747                 free(category->password);
 748
 749         _EXTERN_FUNC_EXIT;
 750 }