libpurple/protocols/novell/nmcontact.c

   1 /*
   2  * nmcontact.c
   3  *
   4  * Copyright (c) 2004 Novell, Inc. All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA        02111-1301      USA
  18  *
  19  */
  20
  21 #include <glib.h>
  22 #include <string.h>
  23 #include "nmcontact.h"
  24 #include "nmfield.h"
  25 #include "nmuser.h"
  26 #include "util.h"
  27
  28 struct _NMContact
  29 {
  30         int id;
  31         int parent_id;
  32         int seq;
  33         char *dn;
  34         char *display_name;
  35         NMUserRecord *user_record;
  36         gpointer data;
  37         int ref_count;
  38 };
  39
  40 struct _NMFolder
  41 {
  42         int id;
  43         int seq;
  44         char *name;
  45         GSList *folders;
  46         GSList *contacts;
  47         int ref_count;
  48 };
  49
  50 static int count = 0;
  51
  52 static void _release_folder_contacts(NMFolder * folder);
  53 static void _release_folder_folders(NMFolder * folder);
  54 static void _add_contacts(NMUser * user, NMFolder * folder, NMField * fields);
  55 static void _add_folders(NMFolder * root, NMField * fields);
  56
  57 /*********************************************************************
  58  * Contact API
  59  *********************************************************************/
  60
  61 NMContact *
  62 nm_create_contact()
  63 {
  64         NMContact *contact = g_new0(NMContact, 1);
  65
  66         contact->ref_count = 1;
  67
  68         purple_debug(PURPLE_DEBUG_INFO, "novell", "Creating contact, total=%d\n",
  69                            count++);
  70
  71         return contact;
  72 }
  73
  74 /*
  75  * This creates a contact for the contact list. The
  76  * field array that is passed in should be a
  77  * NM_A_FA_CONTACT array.
  78  *
  79  */
  80 NMContact *
  81 nm_create_contact_from_fields(NMField * fields)
  82 {
  83         NMContact *contact;
  84         NMField *field;
  85
  86         if ( fields == NULL || fields->tag == NULL || fields->ptr_value == 0 ||
  87                  !purple_strequal(fields->tag, NM_A_FA_CONTACT) )
  88         {
  89                 return NULL;
  90         }
  91
  92         contact = nm_create_contact();
  93
  94         if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->ptr_value))) {
  95
  96                 if (field->ptr_value)
  97                         contact->id = atoi((char *) field->ptr_value);
  98
  99         }
 100
 101         if ((field = nm_locate_field(NM_A_SZ_PARENT_ID, (NMField *) fields->ptr_value))) {
 102
 103                 if (field->ptr_value)
 104                         contact->parent_id = atoi((char *) field->ptr_value);
 105
 106         }
 107
 108         if ((field =
 109                  nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->ptr_value))) {
 110
 111                 if (field->ptr_value)
 112                         contact->seq = atoi((char *) field->ptr_value);
 113
 114         }
 115
 116         if ((field =
 117                  nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->ptr_value))) {
 118
 119                 if (field->ptr_value)
 120                         contact->display_name = g_strdup((char *) field->ptr_value);
 121
 122         }
 123
 124         if ((field = nm_locate_field(NM_A_SZ_DN, (NMField *) fields->ptr_value))) {
 125
 126                 if (field->ptr_value)
 127                         contact->dn = g_strdup((char *) field->ptr_value);
 128
 129         }
 130
 131         return contact;
 132 }
 133
 134 void
 135 nm_contact_update_list_properties(NMContact * contact, NMField * fields)
 136 {
 137         NMField *field;
 138
 139         if (contact == NULL || fields == NULL || fields->ptr_value == 0)
 140                 return;
 141
 142         if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->ptr_value))) {
 143
 144                 if (field->ptr_value)
 145                         contact->id = atoi((char *)field->ptr_value);
 146
 147         }
 148
 149         if ((field = nm_locate_field(NM_A_SZ_PARENT_ID, (NMField *) fields->ptr_value))) {
 150
 151                 if (field->ptr_value)
 152                         contact->parent_id = atoi((char *) field->ptr_value);
 153
 154         }
 155
 156         if ((field =
 157                  nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->ptr_value))) {
 158
 159                 if (field->ptr_value)
 160                         contact->seq = atoi((char *) field->ptr_value);
 161
 162         }
 163
 164         if ((field =
 165                  nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->ptr_value))) {
 166
 167                 if (field->ptr_value) {
 168                         g_free(contact->display_name);
 169
 170                         contact->display_name = g_strdup((char *) field->ptr_value);
 171                 }
 172
 173         }
 174
 175         if ((field = nm_locate_field(NM_A_SZ_DN, (NMField *) fields->ptr_value))) {
 176
 177                 if (field->ptr_value) {
 178                         g_free(contact->dn);
 179
 180                         contact->dn = g_strdup((char *) field->ptr_value);
 181                 }
 182
 183         }
 184 }
 185
 186 NMField *
 187 nm_contact_to_fields(NMContact * contact)
 188 {
 189         NMField *fields = NULL;
 190
 191         if (contact == NULL)
 192                 return NULL;
 193
 194         fields = nm_field_add_pointer(fields, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
 195                                                                   g_strdup_printf("%d", contact->id), NMFIELD_TYPE_UTF8);
 196
 197         fields = nm_field_add_pointer(fields, NM_A_SZ_PARENT_ID, 0, NMFIELD_METHOD_VALID, 0,
 198                                                                   g_strdup_printf("%d", contact->parent_id), NMFIELD_TYPE_UTF8);
 199
 200         fields = nm_field_add_pointer(fields, NM_A_SZ_SEQUENCE_NUMBER, 0, NMFIELD_METHOD_VALID, 0,
 201                                                                   g_strdup_printf("%d", contact->seq), NMFIELD_TYPE_UTF8);
 202
 203         if (contact->display_name != NULL) {
 204                 fields = nm_field_add_pointer(fields, NM_A_SZ_DISPLAY_NAME, 0, NMFIELD_METHOD_VALID, 0,
 205                                                                           g_strdup(contact->display_name), NMFIELD_TYPE_UTF8);
 206         }
 207
 208         if (contact->dn != NULL) {
 209                 fields = nm_field_add_pointer(fields, NM_A_SZ_DN, 0, NMFIELD_METHOD_VALID, 0,
 210                                                                           g_strdup(contact->dn), NMFIELD_TYPE_UTF8);
 211         }
 212
 213         return fields;
 214 }
 215
 216 void
 217 nm_contact_add_ref(NMContact * contact)
 218 {
 219         if (contact)
 220                 contact->ref_count++;
 221 }
 222
 223 void
 224 nm_release_contact(NMContact * contact)
 225 {
 226         if (contact == NULL)
 227                 return;
 228
 229         if (--(contact->ref_count) == 0) {
 230
 231                 purple_debug(PURPLE_DEBUG_INFO, "novell",
 232                                    "Releasing contact, total=%d\n", --count);
 233
 234                 g_free(contact->display_name);
 235                 g_free(contact->dn);
 236
 237                 if (contact->user_record) {
 238                         nm_release_user_record(contact->user_record);
 239                 }
 240
 241                 g_free(contact);
 242         }
 243
 244 }
 245
 246 const char *
 247 nm_contact_get_display_name(NMContact * contact)
 248 {
 249         if (contact == NULL)
 250                 return NULL;
 251
 252         if (contact->user_record != NULL && contact->display_name == NULL) {
 253                 const char *full_name, *lname, *fname, *cn, *display_id;
 254
 255                 full_name = nm_user_record_get_full_name(contact->user_record);
 256                 fname = nm_user_record_get_first_name(contact->user_record);
 257                 lname = nm_user_record_get_last_name(contact->user_record);
 258                 cn = nm_user_record_get_userid(contact->user_record);
 259                 display_id = nm_user_record_get_display_id(contact->user_record);
 260
 261                 /* Try to build a display name. */
 262                 if (full_name) {
 263
 264                         contact->display_name = g_strdup(full_name);
 265
 266                 } else if (fname && lname) {
 267
 268                         contact->display_name = g_strdup_printf("%s %s", fname, lname);
 269
 270                 } else {
 271
 272                         /* If auth attribute is set use it */
 273                         if (nm_user_record_get_auth_attr(contact->user_record) &&
 274                                 display_id != NULL)     {
 275
 276                                 contact->display_name = g_strdup(display_id);
 277
 278                         } else {
 279
 280                                 /* Use CN or display id */
 281                                 if (cn) {
 282
 283                                         contact->display_name = g_strdup(cn);
 284
 285                                 } else if (display_id) {
 286
 287                                         contact->display_name = g_strdup(display_id);
 288
 289                                 }
 290
 291                         }
 292
 293                 }
 294         }
 295
 296         return contact->display_name;
 297 }
 298
 299 void
 300 nm_contact_set_display_name(NMContact * contact, const char *display_name)
 301 {
 302         if (contact == NULL)
 303                 return;
 304
 305         g_free(contact->display_name);
 306         contact->display_name = NULL;
 307
 308         if (display_name)
 309                 contact->display_name = g_strdup(display_name);
 310 }
 311
 312 void
 313 nm_contact_set_dn(NMContact * contact, const char *dn)
 314 {
 315         if (contact == NULL)
 316                 return;
 317
 318         g_free(contact->dn);
 319         contact->dn = NULL;
 320
 321         if (dn)
 322                 contact->dn = g_strdup(dn);
 323 }
 324
 325 const char *
 326 nm_contact_get_dn(NMContact * contact)
 327 {
 328         if (contact == NULL)
 329                 return NULL;
 330
 331         return contact->dn;
 332 }
 333
 334 gpointer
 335 nm_contact_get_data(NMContact * contact)
 336 {
 337         if (contact == NULL)
 338                 return NULL;
 339
 340         return contact->data;
 341 }
 342
 343 int
 344 nm_contact_get_id(NMContact * contact)
 345 {
 346         if (contact == NULL)
 347                 return -1;
 348
 349         return contact->id;
 350 }
 351
 352 int
 353 nm_contact_get_parent_id(NMContact * contact)
 354 {
 355         if (contact == NULL)
 356                 return -1;
 357
 358         return contact->parent_id;
 359 }
 360
 361 void
 362 nm_contact_set_data(NMContact * contact, gpointer data)
 363 {
 364         if (contact == NULL)
 365                 return;
 366
 367         contact->data = data;
 368 }
 369
 370 void
 371 nm_contact_set_user_record(NMContact * contact, NMUserRecord * user_record)
 372 {
 373         if (contact == NULL)
 374                 return;
 375
 376         if (contact->user_record) {
 377                 nm_release_user_record(contact->user_record);
 378         }
 379
 380         nm_user_record_add_ref(user_record);
 381         contact->user_record = user_record;
 382 }
 383
 384 NMUserRecord *
 385 nm_contact_get_user_record(NMContact * contact)
 386 {
 387         if (contact == NULL)
 388                 return NULL;
 389
 390         return contact->user_record;
 391 }
 392
 393 const char *
 394 nm_contact_get_userid(NMContact * contact)
 395 {
 396         NMUserRecord *user_record;
 397         const char *userid = NULL;
 398
 399         if (contact == NULL)
 400                 return NULL;
 401
 402         user_record = nm_contact_get_user_record(contact);
 403         if (user_record) {
 404                 userid = nm_user_record_get_userid(user_record);
 405         }
 406
 407         return userid;
 408 }
 409
 410 const char *
 411 nm_contact_get_display_id(NMContact * contact)
 412 {
 413         NMUserRecord *user_record;
 414         const char *id = NULL;
 415
 416         if (contact == NULL)
 417                 return NULL;
 418
 419         user_record = nm_contact_get_user_record(contact);
 420         if (user_record) {
 421                 id = nm_user_record_get_display_id(user_record);
 422         }
 423
 424         return id;
 425 }
 426
 427
 428 /*********************************************************************
 429  * Folder API
 430  *********************************************************************/
 431
 432 NMFolder *
 433 nm_create_folder(const char *name)
 434 {
 435         NMFolder *folder = g_new0(NMFolder, 1);
 436
 437         if (name)
 438                 folder->name = g_strdup(name);
 439
 440         folder->ref_count = 1;
 441
 442         return folder;
 443 }
 444
 445 NMFolder *
 446 nm_create_folder_from_fields(NMField * fields)
 447 {
 448         NMField *field;
 449         NMFolder *folder;
 450
 451         if (fields == NULL || fields->ptr_value == 0)
 452                 return NULL;
 453
 454         folder = g_new0(NMFolder, 1);
 455
 456         if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->ptr_value))) {
 457
 458                 if (field->ptr_value)
 459                         folder->id = atoi((char *) field->ptr_value);
 460         }
 461
 462         if ((field =
 463                  nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->ptr_value))) {
 464
 465                 if (field->ptr_value)
 466                         folder->seq = atoi((char *) field->ptr_value);
 467         }
 468
 469         if ((field =
 470                  nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->ptr_value))) {
 471
 472                 if (field->ptr_value)
 473                         folder->name = g_strdup((char *) field->ptr_value);
 474         }
 475
 476         folder->ref_count = 1;
 477         return folder;
 478 }
 479
 480 NMField *
 481 nm_folder_to_fields(NMFolder * folder)
 482 {
 483         NMField *fields = NULL;
 484
 485         if (folder == NULL)
 486                 return NULL;
 487
 488         fields = nm_field_add_pointer(fields, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
 489                                                                   g_strdup_printf("%d", folder->id), NMFIELD_TYPE_UTF8);
 490
 491         fields = nm_field_add_pointer(fields, NM_A_SZ_PARENT_ID, 0, NMFIELD_METHOD_VALID, 0,
 492                                                                   g_strdup("0"), NMFIELD_TYPE_UTF8);
 493
 494         fields = nm_field_add_pointer(fields, NM_A_SZ_TYPE, 0, NMFIELD_METHOD_VALID, 0,
 495                                                                   g_strdup("1"), NMFIELD_TYPE_UTF8);
 496
 497         fields = nm_field_add_pointer(fields, NM_A_SZ_SEQUENCE_NUMBER, 0, NMFIELD_METHOD_VALID, 0,
 498                                                                   g_strdup_printf("%d", folder->seq), NMFIELD_TYPE_UTF8);
 499
 500         if (folder->name != NULL) {
 501                 fields = nm_field_add_pointer(fields, NM_A_SZ_DISPLAY_NAME, 0, NMFIELD_METHOD_VALID, 0,
 502                                                                           g_strdup(folder->name), NMFIELD_TYPE_UTF8);
 503         }
 504
 505
 506         return fields;
 507 }
 508
 509 void
 510 nm_folder_update_list_properties(NMFolder * folder, NMField * fields)
 511 {
 512         NMField *field;
 513
 514         if (folder == NULL || fields == NULL || fields->ptr_value == 0)
 515                 return;
 516
 517         if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->ptr_value))) {
 518
 519                 if (field->ptr_value)
 520                         folder->id = atoi((char *) field->ptr_value);
 521
 522         }
 523
 524         if ((field =
 525                  nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->ptr_value))) {
 526
 527                 if (field->ptr_value)
 528                         folder->seq = atoi((char *) field->ptr_value);
 529
 530         }
 531
 532         if ((field =
 533                  nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->ptr_value))) {
 534
 535                 if (field->ptr_value) {
 536                         g_free(folder->name);
 537
 538                         folder->name = g_strdup((char *) field->ptr_value);
 539                 }
 540
 541         }
 542
 543 }
 544
 545 void
 546 nm_release_folder(NMFolder * folder)
 547 {
 548         if (folder == NULL)
 549                 return;
 550
 551         if (--(folder->ref_count) == 0) {
 552                 g_free(folder->name);
 553
 554                 if (folder->folders) {
 555                         _release_folder_folders(folder);
 556                 }
 557
 558                 if (folder->contacts) {
 559                         _release_folder_contacts(folder);
 560                 }
 561
 562                 g_free(folder);
 563         }
 564 }
 565
 566
 567 void
 568 nm_folder_add_ref(NMFolder * folder)
 569 {
 570         if (folder)
 571                 folder->ref_count++;
 572 }
 573
 574 int
 575 nm_folder_get_subfolder_count(NMFolder * folder)
 576 {
 577         if (folder == NULL)
 578                 return 0;
 579
 580         if (folder->folders)
 581                 return g_slist_length(folder->folders);
 582         else
 583                 return 0;
 584 }
 585
 586 NMFolder *
 587 nm_folder_get_subfolder(NMFolder * folder, int index)
 588 {
 589         if (folder == NULL)
 590                 return NULL;
 591
 592         if (folder->folders)
 593                 return (NMFolder *) g_slist_nth_data(folder->folders, index);
 594         else
 595                 return NULL;
 596 }
 597
 598 int
 599 nm_folder_get_contact_count(NMFolder * folder)
 600 {
 601         if (folder == NULL)
 602                 return 0;
 603
 604         if (folder->contacts != NULL)
 605                 return g_slist_length(folder->contacts);
 606         else
 607                 return 0;
 608 }
 609
 610 NMContact *
 611 nm_folder_get_contact(NMFolder * folder, int index)
 612 {
 613         if (folder == NULL)
 614                 return NULL;
 615
 616         if (folder->contacts)
 617                 return (NMContact *) g_slist_nth_data(folder->contacts, index);
 618         else
 619                 return NULL;
 620 }
 621
 622 const char *
 623 nm_folder_get_name(NMFolder * folder)
 624 {
 625         if (folder == NULL)
 626                 return NULL;
 627
 628         return folder->name;
 629 }
 630
 631 void
 632 nm_folder_set_name(NMFolder * folder, const char *name)
 633 {
 634         if (folder == NULL || name == NULL)
 635                 return;
 636
 637         g_free(folder->name);
 638
 639         folder->name = g_strdup(name);
 640 }
 641
 642 int
 643 nm_folder_get_id(NMFolder * folder)
 644 {
 645         if (folder == NULL) {
 646                 return  -1;
 647         }
 648
 649         return folder->id;
 650 }
 651
 652 void
 653 nm_folder_add_folder_to_list(NMFolder * root, NMFolder * folder)
 654 {
 655         GSList *node;
 656
 657         if (root == NULL || folder == NULL)
 658                 return;
 659
 660         node = root->folders;
 661         while (node) {
 662                 if (folder->seq <= ((NMFolder *) node->data)->seq) {
 663                         nm_folder_add_ref(folder);
 664                         root->folders = g_slist_insert_before(root->folders, node, folder);
 665                         break;
 666                 }
 667                 node = g_slist_next(node);
 668         }
 669         if (node == NULL) {
 670                 nm_folder_add_ref(folder);
 671                 root->folders = g_slist_append(root->folders, folder);
 672         }
 673 }
 674
 675 void
 676 nm_folder_remove_contact(NMFolder * folder, NMContact * contact)
 677 {
 678         GSList *node;
 679
 680         if (folder == NULL || contact == NULL)
 681                 return;
 682
 683         node = folder->contacts;
 684         while (node) {
 685                 if (contact->id == ((NMContact *) (node->data))->id) {
 686                         folder->contacts = g_slist_remove(folder->contacts, node->data);
 687                         nm_release_contact(contact);
 688                         break;
 689                 }
 690                 node = g_slist_next(node);
 691         }
 692 }
 693
 694 void
 695 nm_folder_add_contact_to_list(NMFolder * root_folder, NMContact * contact)
 696 {
 697         GSList *node = NULL;
 698         NMFolder *folder = root_folder;
 699
 700         if (folder == NULL || contact == NULL)
 701                 return;
 702
 703         /* Find folder to add contact to */
 704         if (contact->parent_id != 0) {
 705                 node = folder->folders;
 706                 while (node) {
 707                         folder = (NMFolder *) node->data;
 708                         if (contact->parent_id == folder->id) {
 709                                 break;
 710                         }
 711                         folder = NULL;
 712                         node = g_slist_next(node);
 713                 }
 714         }
 715
 716         /* Add contact to list */
 717         if (folder) {
 718                 node = folder->contacts;
 719                 while (node) {
 720                         if (contact->seq <= ((NMContact *) (node->data))->seq) {
 721                                 nm_contact_add_ref(contact);
 722                                 folder->contacts =
 723                                         g_slist_insert_before(folder->contacts, node, contact);
 724                                 break;
 725                         }
 726                         node = g_slist_next(node);
 727                 }
 728
 729                 if (node == NULL) {
 730                         nm_contact_add_ref(contact);
 731                         folder->contacts = g_slist_append(folder->contacts, contact);
 732                 }
 733         }
 734 }
 735
 736 void
 737 nm_folder_add_contacts_and_folders(NMUser * user, NMFolder * root,
 738                                                                    NMField * fields)
 739 {
 740         /* Add the contacts and folders from the field array */
 741         if (user && root && fields) {
 742                 _add_folders(root, fields);
 743                 _add_contacts(user, root, fields);
 744         }
 745 }
 746
 747 gpointer
 748 nm_folder_find_item_by_object_id(NMFolder * root_folder, int object_id)
 749 {
 750         int cnt, cnt2, i, j;
 751         gpointer item = NULL;
 752         NMFolder *folder;
 753         NMContact *contact;
 754
 755         if (root_folder == NULL)
 756                 return NULL;
 757
 758         /* Check all contacts for the top level folder */
 759         cnt = nm_folder_get_contact_count(root_folder);
 760         for (i = 0; i < cnt; i++) {
 761                 contact = nm_folder_get_contact(root_folder, i);
 762                 if (contact && (contact->id == object_id)) {
 763                         item = contact;
 764                         break;
 765                 }
 766         }
 767
 768         /* If we haven't found the item yet, check the subfolders */
 769         if (item == NULL) {
 770                 cnt = nm_folder_get_subfolder_count(root_folder);
 771                 for (i = 0; (i < cnt) && (item == NULL); i++) {
 772                         folder = nm_folder_get_subfolder(root_folder, i);
 773
 774                         /* Check the id of this folder */
 775                         if (folder && (folder->id == object_id)) {
 776                                 item = folder;
 777                                 break;
 778                         }
 779
 780                         /* Check all contacts for this folder */
 781                         cnt2 = nm_folder_get_contact_count(folder);
 782                         for (j = 0; j < cnt2; j++) {
 783                                 contact = nm_folder_get_contact(folder, j);
 784                                 if (contact && (contact->id == object_id)) {
 785                                         item = contact;
 786                                         break;
 787                                 }
 788                         }
 789                 }
 790         }
 791
 792         return item;
 793 }
 794
 795 NMContact *
 796 nm_folder_find_contact_by_userid(NMFolder * folder, const char *userid)
 797 {
 798         int cnt, i;
 799         NMContact *tmp, *contact = NULL;
 800
 801         if (folder == NULL || userid == NULL)
 802                 return NULL;
 803
 804         cnt = nm_folder_get_contact_count(folder);
 805         for (i = 0; i < cnt; i++) {
 806                 tmp = nm_folder_get_contact(folder, i);
 807                 if (tmp && nm_utf8_str_equal(nm_contact_get_userid(tmp), userid)) {
 808                         contact = tmp;
 809                         break;
 810                 }
 811         }
 812
 813         return contact;
 814 }
 815
 816 NMContact *
 817 nm_folder_find_contact_by_display_id(NMFolder * folder, const char *display_id)
 818 {
 819         int cnt, i;
 820         NMContact *tmp, *contact = NULL;
 821
 822         if (folder == NULL || display_id == NULL)
 823                 return NULL;
 824
 825         cnt = nm_folder_get_contact_count(folder);
 826         for (i = 0; i < cnt; i++) {
 827                 tmp = nm_folder_get_contact(folder, i);
 828                 if (tmp && nm_utf8_str_equal(nm_contact_get_display_id(tmp), display_id)) {
 829                         contact = tmp;
 830                         break;
 831                 }
 832         }
 833
 834         return contact;
 835 }
 836
 837 NMContact *
 838 nm_folder_find_contact(NMFolder * folder, const char *dn)
 839 {
 840         int cnt, i;
 841         NMContact *tmp, *contact = NULL;
 842
 843         if (folder == NULL || dn == NULL)
 844                 return NULL;
 845
 846         cnt = nm_folder_get_contact_count(folder);
 847         for (i = 0; i < cnt; i++) {
 848                 tmp = nm_folder_get_contact(folder, i);
 849                 if (tmp && nm_utf8_str_equal(nm_contact_get_dn(tmp), dn)) {
 850                         contact = tmp;
 851                         break;
 852                 }
 853         }
 854
 855         return contact;
 856 }
 857
 858
 859 /*********************************************************************
 860  * Utility functions
 861  *********************************************************************/
 862
 863 static void
 864 _release_folder_contacts(NMFolder * folder)
 865 {
 866         GSList *cnode;
 867         NMContact *contact;
 868
 869         for (cnode = folder->contacts; cnode; cnode = cnode->next) {
 870                 contact = cnode->data;
 871                 cnode->data = NULL;
 872                 nm_release_contact(contact);
 873         }
 874
 875         g_slist_free(folder->contacts);
 876         folder->contacts = NULL;
 877 }
 878
 879 static void
 880 _release_folder_folders(NMFolder * folder)
 881 {
 882         GSList *fnode;
 883         NMFolder *subfolder;
 884
 885         if (folder == NULL)
 886                 return;
 887
 888         for (fnode = folder->folders; fnode; fnode = fnode->next) {
 889                 subfolder = fnode->data;
 890                 fnode->data = NULL;
 891                 nm_release_folder(subfolder);
 892         }
 893
 894         g_slist_free(folder->folders);
 895         folder->folders = NULL;
 896 }
 897
 898 static void
 899 _add_folders(NMFolder * root, NMField * fields)
 900 {
 901         NMFolder *folder = NULL;
 902         NMField *locate = NULL;
 903
 904         locate = nm_locate_field(NM_A_FA_FOLDER, fields);
 905         while (locate != NULL) {
 906
 907                 /* Create a new folder */
 908                 folder = nm_create_folder_from_fields(locate);
 909
 910                 /* Add subfolder to roots folder list */
 911                 nm_folder_add_folder_to_list(root, folder);
 912
 913                 /* Decrement the ref count */
 914                 nm_release_folder(folder);
 915
 916                 /* Find the next folder */
 917                 locate = nm_locate_field(NM_A_FA_FOLDER, locate+1);
 918
 919         }
 920 }
 921
 922 static void
 923 _add_contacts(NMUser * user, NMFolder * folder, NMField * fields)
 924 {
 925         NMContact *contact = NULL;
 926         NMField *locate = NULL,  *details;
 927         NMUserRecord *user_record = NULL;
 928
 929         locate = nm_locate_field(NM_A_FA_CONTACT, fields);
 930         while (locate != NULL) {
 931
 932                 /* Create a new contact from the fields */
 933                 contact = nm_create_contact_from_fields(locate);
 934
 935                 /* Add it to our contact list */
 936                 nm_folder_add_contact_to_list(folder, contact);
 937
 938                 /* Update the contact cache */
 939                 nm_user_add_contact(user, contact);
 940
 941                 /* Update the user record cache */
 942                 if ((details = nm_locate_field(NM_A_FA_USER_DETAILS,
 943                                                                            (NMField *) locate->ptr_value))) {
 944                         user_record = nm_find_user_record(user, nm_contact_get_dn(contact));
 945                         if (user_record == NULL) {
 946                                 user_record = nm_create_user_record_from_fields(details);
 947                                 nm_user_record_set_dn(user_record, nm_contact_get_dn(contact));
 948                                 nm_user_add_user_record(user, user_record);
 949                                 nm_release_user_record(user_record);
 950                         }
 951                         nm_contact_set_user_record(contact, user_record);
 952                 }
 953
 954                 nm_release_contact(contact);
 955
 956                 locate = nm_locate_field(NM_A_FA_CONTACT, locate+1);
 957         }
 958 }