src/gcontact.c

   1 /*
   2 Copyright (c) 2008 Instituto Nokia de Tecnologia
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without modification,
   6 are permitted provided that the following conditions are met:
   7
   8     * Redistributions of source code must retain the above copyright notice,
   9     this list of conditions and the following disclaimer.
  10     * Redistributions in binary form must reproduce the above copyright notice,
  11     this list of conditions and the following disclaimer in the documentation
  12     and/or other materials provided with the distribution.
  13     * Neither the name of the INdT nor the names of its contributors
  14     may be used to endorse or promote products derived from this software
  15     without specific prior written permission.
  16
  17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  18 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27 POSSIBILITY OF SUCH DAMAGE.
  28 */
  29 /**
  30  * @file   gcontact.c
  31  * @author Adenilson Cavalcanti da Silva <adenilson.silva@indt.org.br>
  32  * @date   Thu Jun 26 07:37:03 2008
  33  *
  34  * @brief  libgcal google contacts user public API.
  35  *
  36  * Use this functions to handle common tasks when dealing with google contacts.
  37  */
  38
  39 #ifdef HAVE_CONFIG_H
  40 #include "config.h"
  41 #else
  42 #define _GNU_SOURCE
  43 #endif
  44
  45 #include <string.h>
  46 #include <stdio.h>
  47 #include "gcontact.h"
  48 #include "gcal_parser.h"
  49 #include "internal_gcal.h"
  50
  51
  52 /** Strings associated with phone number types */
  53 const char* gcal_phone_type_str[] = {
  54         "assistant",            // P_ASSISTANT
  55         "callback",             // P_CALLBACK
  56         "car",                  // P_CAR
  57         "company_main",         // P_COMPANY_MAIN
  58         "fax",                  // P_FAX
  59         "home",                 // P_HOME
  60         "home_fax",             // P_HOME_FAX
  61         "isdn",                 // P_ISDN
  62         "main",                 // P_MAIN
  63         "mobile",               // P_MOBILE
  64         "other",                // P_OTHER
  65         "other_fax",            // P_OTHER_FAX
  66         "pager",                // P_PAGER
  67         "radio",                // P_RADIO
  68         "telex",                // P_TELEX
  69         "tty_tdd",              // P_TTY_TDD
  70         "work",                 // P_WORK
  71         "work_fax",             // P_WORK_FAX
  72         "work_mobile",          // P_WORK_MOBILE
  73         "work_pager"            // P_WORK_PAGER
  74 };
  75
  76 /** Strings associated with email types */
  77 const char* gcal_email_type_str[] = {
  78         "home",                         // E_HOME
  79         "other",                        // E_OTHER
  80         "work"                          // E_WORK
  81 };
  82
  83 /** Strings associated with address types */
  84 const char* gcal_address_type_str[] = {
  85         "home",                         // A_HOME
  86         "work",                         // A_WORK
  87         "other"                         // A_OTHER
  88 };
  89
  90 /** Strings associated with im types */
  91 const char* gcal_im_type_str[] = {
  92         "home",                         // I_HOME
  93         "work",                         // I_WORK
  94         "netmeeting",                   // I_NETMEETING
  95         "other"                         // I_OTHER
  96 };
  97
  98 gcal_contact_t gcal_contact_new(const char *raw_xml)
  99 {
 100         gcal_contact_t contact = NULL;
 101         dom_document *doc;
 102         int result = -1;
 103
 104         contact = (gcal_contact_t) malloc(sizeof(struct gcal_contact));
 105         if (!contact)
 106                 goto exit;
 107
 108         gcal_init_contact(contact);
 109         if (!raw_xml)
 110                 goto exit;
 111
 112         /* Builds a doc, parse and init object */
 113         doc = build_dom_document(raw_xml);
 114         if (!doc)
 115                 goto cleanup;
 116
 117         result = extract_all_contacts(doc, contact, 1);
 118         clean_dom_document(doc);
 119
 120 cleanup:
 121         if (result) {
 122                 free(contact);
 123                 contact = NULL;
 124         }
 125 exit:
 126         return contact;
 127 }
 128
 129 void gcal_contact_delete(gcal_contact_t contact)
 130 {
 131         if (!contact)
 132                 return;
 133
 134         gcal_destroy_contact(contact);
 135         free(contact);
 136
 137 }
 138
 139 int gcal_get_contacts(gcal_t gcalobj, struct gcal_contact_array *contact_array)
 140 {
 141         int result = -1;
 142         if (contact_array)
 143                 contact_array->length = 0;
 144
 145         if ((!gcalobj) || (!contact_array))
 146                 return result;
 147
 148         result = gcal_dump(gcalobj, "GData-Version: 3.0");
 149         if (result == -1) {
 150                 contact_array->entries = NULL;
 151                 contact_array->length = 0;
 152                 return result;
 153         }
 154
 155         contact_array->entries = gcal_get_all_contacts(gcalobj,
 156                                                        &contact_array->length);
 157         if (!contact_array->entries)
 158                 return result;
 159
 160         result = 0;
 161
 162         return result;
 163
 164 }
 165
 166 void gcal_cleanup_contacts(struct gcal_contact_array *contacts)
 167 {
 168         if (!contacts)
 169                 return;
 170
 171         gcal_destroy_contacts(contacts->entries, contacts->length);
 172         contacts->length = 0;
 173         contacts->entries = NULL;
 174
 175 }
 176
 177
 178 int gcal_add_contact(gcal_t gcalobj, gcal_contact_t contact)
 179 {
 180         int result = -1;
 181         struct gcal_contact updated;
 182         gcal_init_contact(&updated);
 183
 184         if ((!gcalobj) || (!contact))
 185                 goto exit;
 186
 187
 188         result = gcal_create_contact(gcalobj, contact, &updated);
 189         if (result)
 190                 goto exit;
 191
 192         /* Swap updated fields: id, updated, edit_uri, etag, photo url  */
 193         if (contact->common.id)
 194                 free(contact->common.id);
 195         contact->common.id = updated.common.id;
 196         updated.common.id = NULL;
 197
 198         if (contact->common.updated)
 199                 free(contact->common.updated);
 200         contact->common.updated = updated.common.updated;
 201         updated.common.updated = NULL;
 202
 203         if (contact->common.edit_uri)
 204                 free(contact->common.edit_uri);
 205         contact->common.edit_uri = updated.common.edit_uri;
 206         updated.common.edit_uri = NULL;
 207
 208         if (contact->common.etag)
 209                 free(contact->common.etag);
 210         contact->common.etag = updated.common.etag;
 211         updated.common.etag = NULL;
 212
 213         if (contact->photo)
 214                 free(contact->photo);
 215         contact->photo = updated.photo;
 216         updated.photo = NULL;
 217
 218         /* Cleanup updated contact */
 219         gcal_destroy_contact(&updated);
 220
 221 exit:
 222         return result;
 223 }
 224
 225 int gcal_update_contact(gcal_t gcalobj, gcal_contact_t contact)
 226 {
 227         int result = -1;
 228         struct gcal_contact updated;
 229         gcal_init_contact(&updated);
 230
 231         if ((!gcalobj) || (!contact))
 232                 goto exit;
 233
 234
 235         result = gcal_edit_contact(gcalobj, contact, &updated);
 236         if (result)
 237                 goto exit;
 238
 239         /* Swap updated fields: updated, edit_uri, etag */
 240         if (contact->common.updated)
 241                 free(contact->common.updated);
 242         contact->common.updated = updated.common.updated;
 243         updated.common.updated = NULL;
 244
 245         if (contact->common.edit_uri)
 246                 free(contact->common.edit_uri);
 247         contact->common.edit_uri = updated.common.edit_uri;
 248         updated.common.edit_uri = NULL;
 249
 250         if (contact->common.etag)
 251                 free(contact->common.etag);
 252         contact->common.etag = updated.common.etag;
 253         updated.common.etag = NULL;
 254
 255         if (contact->photo)
 256                 free(contact->photo);
 257         contact->photo = updated.photo;
 258         updated.photo = NULL;
 259
 260         /* Cleanup updated contact */
 261         gcal_destroy_contact(&updated);
 262
 263 exit:
 264         return result;
 265 }
 266
 267 int gcal_erase_contact(gcal_t gcalobj, gcal_contact_t contact)
 268 {
 269         int result = -1;
 270         if ((!gcalobj) || (!contact))
 271                 goto exit;
 272
 273         result = gcal_delete_contact(gcalobj, contact);
 274 exit:
 275         return result;
 276 }
 277
 278 int gcal_get_updated_contacts(gcal_t gcal_obj,
 279                               struct gcal_contact_array *contacts,
 280                               const char *timestamp)
 281 {
 282         int result = -1;
 283         if (contacts)
 284                 contacts->length = 0;
 285
 286         if ((!gcal_obj) || (!contacts))
 287                 return result;
 288
 289         result = gcal_query_updated(gcal_obj, timestamp, "GData-Version: 3.0");
 290         if (result) {
 291                 contacts->entries = NULL;
 292                 contacts->length = 0;
 293                 return result;
 294         }
 295
 296         contacts->entries = gcal_get_all_contacts(gcal_obj, &contacts->length);
 297         if (contacts->entries)
 298                 result = 0;
 299
 300         return result;
 301 }
 302
 303 gcal_contact_t gcal_contact_element(struct gcal_contact_array *contacts,
 304                                     size_t _index)
 305
 306 {
 307         struct gcal_contact *contact = NULL;
 308         if ((!contacts) || (_index > (contacts->length - 1)) ||
 309             (contacts->length == 0))
 310                 return contact;
 311
 312         contact = &contacts->entries[_index];
 313         return contact;
 314 }
 315
 316 const char *gcal_contact_get_xml(gcal_contact_t contact)
 317 {
 318         if ((!contact))
 319                 return NULL;
 320         return gcal_get_xml(&(contact->common));
 321 }
 322
 323 const char *gcal_contact_get_id(gcal_contact_t contact)
 324 {
 325         if ((!contact))
 326                 return NULL;
 327         return gcal_get_id(&(contact->common));
 328 }
 329
 330 const char *gcal_contact_get_updated(gcal_contact_t contact)
 331 {
 332         if ((!contact))
 333                 return NULL;
 334         return gcal_get_updated(&(contact->common));
 335 }
 336
 337 const char *gcal_contact_get_title(gcal_contact_t contact)
 338 {
 339         if ((!contact))
 340                 return NULL;
 341         return gcal_get_title(&(contact->common));
 342 }
 343
 344 const char *gcal_contact_get_url(gcal_contact_t contact)
 345 {
 346         if ((!contact))
 347                 return NULL;
 348         return gcal_get_url(&(contact->common));
 349 }
 350
 351 const char *gcal_contact_get_etag(gcal_contact_t contact)
 352 {
 353         if ((!contact))
 354                 return NULL;
 355         return gcal_get_etag(&(contact->common));
 356 }
 357
 358 char gcal_contact_is_deleted(gcal_contact_t contact)
 359 {
 360         if ((!contact))
 361                 return -1;
 362         return gcal_get_deleted(&(contact->common));
 363 }
 364
 365
 366 /* This are the fields unique to contacts */
 367 int gcal_contact_get_emails_count(gcal_contact_t contact)
 368 {
 369         if ((!contact))
 370                 return -1;
 371         return contact->emails_nr;
 372 }
 373
 374 int gcal_contact_get_pref_email(gcal_contact_t contact)
 375 {
 376         if ((!contact))
 377                 return -1;
 378         return contact->pref_email;
 379 }
 380
 381 const char *gcal_contact_get_email_address(gcal_contact_t contact, int i)
 382 {
 383         if ((!contact))
 384                 return NULL;
 385         if (!(contact->emails_field) || (i >= contact->emails_nr))
 386                 return NULL;
 387         return contact->emails_field[i];
 388 }
 389
 390 const char *gcal_contact_get_email(gcal_contact_t contact)
 391 {
 392         int tmp;
 393         if ((!contact))
 394                 return NULL;
 395
 396         tmp = gcal_contact_get_pref_email(contact);
 397         return gcal_contact_get_email_address(contact, tmp);
 398 }
 399
 400 gcal_email_type gcal_contact_get_email_address_type(gcal_contact_t contact, int i)
 401 {
 402         gcal_email_type result = E_INVALID;
 403         int j;
 404
 405         if ((!contact))
 406                 return result;
 407         if (!(contact->emails_type) || (i >= contact->emails_nr))
 408                 return result;
 409         for (j = 0; j < E_ITEMS_COUNT; j++)
 410                 if (!strcmp(contact->emails_type[i], gcal_email_type_str[j]))
 411                         result = j;
 412         return result;
 413 }
 414
 415 const char *gcal_contact_get_content(gcal_contact_t contact)
 416 {
 417         if ((!contact))
 418                 return NULL;
 419         return contact->content;
 420 }
 421
 422 const char *gcal_contact_get_nickname(gcal_contact_t contact)
 423 {
 424         if ((!contact))
 425                 return NULL;
 426         return contact->nickname;
 427 }
 428
 429 const char *gcal_contact_get_organization(gcal_contact_t contact)
 430 {
 431         if ((!contact))
 432                 return NULL;
 433         return contact->org_name;
 434 }
 435
 436 const char *gcal_contact_get_profession(gcal_contact_t contact)
 437 {
 438         if ((!contact))
 439                 return NULL;
 440         return contact->org_title;
 441 }
 442
 443 const char *gcal_contact_get_occupation(gcal_contact_t contact)
 444 {
 445         if ((!contact))
 446                 return NULL;
 447         return contact->occupation;
 448 }
 449
 450 const char *gcal_contact_get_homepage(gcal_contact_t contact)
 451 {
 452         if ((!contact))
 453                 return NULL;
 454         return contact->homepage;
 455 }
 456
 457 const char *gcal_contact_get_blog(gcal_contact_t contact)
 458 {
 459         if ((!contact))
 460                 return NULL;
 461         return contact->blog;
 462 }
 463
 464 int gcal_contact_get_phone_numbers_count(gcal_contact_t contact)
 465 {
 466         if ((!contact))
 467                 return -1;
 468         return contact->phone_numbers_nr;
 469 }
 470
 471 const char *gcal_contact_get_phone_number(gcal_contact_t contact, int i)
 472 {
 473         if ((!contact))
 474                 return NULL;
 475         if (!(contact->phone_numbers_field) || (i >= contact->phone_numbers_nr))
 476                 return NULL;
 477         return contact->phone_numbers_field[i];
 478 }
 479
 480 const char *gcal_contact_get_phone(gcal_contact_t contact)
 481 {
 482         if ((!contact))
 483                 return NULL;
 484
 485         const char *res;
 486         /* The prefered phone is *always* the first */
 487         res = gcal_contact_get_phone_number(contact, 0);
 488         return res;
 489 }
 490
 491 gcal_phone_type gcal_contact_get_phone_number_type(gcal_contact_t contact, int i)
 492 {
 493         gcal_phone_type result = P_INVALID;
 494         int j;
 495
 496         if ((!contact))
 497                 return result;
 498         if (!(contact->phone_numbers_type) || (i >= contact->phone_numbers_nr))
 499                 return result;
 500         for (j = 0; j < P_ITEMS_COUNT; j++)
 501                 if (!strcmp(contact->phone_numbers_type[i], gcal_phone_type_str[j]))
 502                         result = j;
 503         return result;
 504 }
 505
 506 const char *gcal_contact_get_im(gcal_contact_t contact)
 507 {
 508         if ((!contact))
 509                 return NULL;
 510         if (!(contact->im_address))
 511                 return NULL;
 512
 513         const char *res;
 514         int pref_im;
 515         pref_im = gcal_contact_get_pref_im(contact);
 516         if(pref_im == -1)
 517                 pref_im = 0;
 518         res = gcal_contact_get_im_address(contact, pref_im);
 519         return res;
 520 }
 521
 522 int gcal_contact_get_im_count(gcal_contact_t contact)
 523 {
 524         if ((!contact))
 525                 return -1;
 526         return contact->im_nr;
 527 }
 528
 529 int gcal_contact_get_pref_im(gcal_contact_t contact)
 530 {
 531         if ((!contact))
 532                 return -1;
 533         return contact->im_pref;
 534 }
 535
 536 const char *gcal_contact_get_im_protocol(gcal_contact_t contact, int i)
 537 {
 538         if ((!contact))
 539                 return NULL;
 540         if (!(contact->im_protocol) || (i >= contact->im_nr))
 541                 return NULL;
 542         return contact->im_protocol[i];
 543 }
 544
 545 const char *gcal_contact_get_im_address(gcal_contact_t contact, int i)
 546 {
 547         if ((!contact))
 548                 return NULL;
 549         if (!(contact->im_address) || (i >= contact->im_nr))
 550                 return NULL;
 551         return contact->im_address[i];
 552 }
 553
 554 gcal_phone_type gcal_contact_get_im_type(gcal_contact_t contact, int i)
 555 {
 556         gcal_im_type result = P_INVALID;
 557         int j;
 558
 559         if ((!contact))
 560                 return result;
 561         if (!(contact->im_type) || (i >= contact->im_nr))
 562                 return result;
 563         for (j = 0; j < I_ITEMS_COUNT; j++)
 564                 if (!strcmp(contact->im_type[i], gcal_im_type_str[j]))
 565                         result = j;
 566         return result;
 567 }
 568
 569 gcal_structured_subvalues_t gcal_contact_get_structured_name(gcal_contact_t contact)
 570 {
 571         if ((!contact) || (!contact->structured_name))
 572                 return NULL;
 573         return contact->structured_name;
 574 }
 575
 576 const char *gcal_contact_get_address(gcal_contact_t contact)
 577 {
 578         if ((!contact))
 579                 return NULL;
 580         return contact->post_address;
 581 }
 582
 583 gcal_structured_subvalues_t gcal_contact_get_structured_address(gcal_contact_t contact)
 584 {
 585         if ((!contact) || (!contact->structured_address))
 586                 return NULL;
 587         return contact->structured_address;
 588 }
 589
 590 int gcal_contact_get_structured_address_count(gcal_contact_t contact)
 591 {
 592         if ((!contact))
 593                 return -1;
 594         return contact->structured_address_nr;
 595 }
 596
 597 const int *gcal_contact_get_structured_address_count_obj(gcal_contact_t contact)
 598 {
 599         if ((!contact))
 600                 return NULL;
 601         return &contact->structured_address_nr;
 602 }
 603
 604 const char *gcal_contact_get_structured_entry(gcal_structured_subvalues_t structured_entry,
 605                                         int structured_entry_nr,
 606                                         int structured_entry_count,
 607                                         const char *field_key)
 608 {
 609         struct gcal_structured_subvalues *temp_structured_entry;
 610
 611         if(field_key == NULL)
 612                 field_key = "";
 613
 614         if (!structured_entry || (structured_entry_nr >= structured_entry_count))
 615                 return NULL;
 616
 617         for (temp_structured_entry = structured_entry;
 618              temp_structured_entry != NULL;
 619              temp_structured_entry = temp_structured_entry->next_field) {
 620
 621                 if (temp_structured_entry->next_field != NULL) {
 622                         if (!strcmp(temp_structured_entry->field_key, field_key)
 623                             && (temp_structured_entry->field_typenr == structured_entry_nr)) {
 624                                 return temp_structured_entry->field_value;
 625                         }
 626                 }
 627         }
 628
 629         return NULL;
 630 }
 631
 632 char ***gcal_contact_get_structured_address_type_obj(gcal_contact_t contact)
 633 {
 634         if ((!contact))
 635                 return NULL;
 636         return &contact->structured_address_type;
 637 }
 638
 639 gcal_address_type gcal_contact_get_structured_address_type(gcal_contact_t contact,
 640                                                            int structured_entry_nr,
 641                                                            int structured_entry_count)
 642 {
 643         gcal_address_type result = A_INVALID;
 644         int j;
 645
 646         if ((!contact))
 647                 return result;
 648
 649         if (!(contact->structured_address_type) ||
 650             (structured_entry_nr >= structured_entry_count))
 651                 return result;
 652
 653         for (j = 0; j < A_ITEMS_COUNT; j++)
 654                 if (!strcmp(contact->structured_address_type[structured_entry_nr], gcal_address_type_str[j]))
 655                         result = j;
 656
 657         return result;
 658 }
 659
 660 int gcal_contact_get_pref_structured_address(gcal_contact_t contact)
 661 {
 662         if ((!contact))
 663                 return -1;
 664         return contact->structured_address_pref;
 665 }
 666
 667 int gcal_contact_get_groupMembership_count(gcal_contact_t contact)
 668 {
 669         if ((!contact))
 670                 return -1;
 671         return contact->groupMembership_nr;
 672 }
 673
 674 const char *gcal_contact_get_groupMembership(gcal_contact_t contact, int i)
 675 {
 676         if ((!contact))
 677                 return NULL;
 678         if (!(contact->groupMembership) || (i >= contact->groupMembership_nr))
 679                 return NULL;
 680         return contact->groupMembership[i];
 681 }
 682
 683 const char *gcal_contact_get_photo(gcal_contact_t contact)
 684 {
 685         if ((!contact))
 686                 return NULL;
 687
 688         return contact->photo_data;
 689 }
 690
 691 unsigned int gcal_contact_get_photolength(gcal_contact_t contact)
 692 {
 693         if ((!contact))
 694                 return -1;
 695
 696         return contact->photo_length;
 697 }
 698
 699 const char *gcal_contact_get_birthday(gcal_contact_t contact)
 700 {
 701         if ((!contact))
 702                 return NULL;
 703         return contact->birthday;
 704 }
 705
 706 /* Here starts the gcal_contact setters */
 707 int gcal_contact_set_title(gcal_contact_t contact, const char *field)
 708 {
 709         int result = -1;
 710
 711         if ((!contact) || (!field))
 712                 return result;
 713
 714         if (contact->common.title)
 715                 free(contact->common.title);
 716
 717         contact->common.title = strdup(field);
 718         if (contact->common.title)
 719                 result = 0;
 720
 721         return result;
 722 }
 723
 724 int gcal_contact_delete_email_addresses(gcal_contact_t contact)
 725 {
 726         int result = -1;
 727         int temp;
 728
 729         if (!contact)
 730                 return result;
 731
 732         if (contact->emails_nr > 0) {
 733                 for (temp = 0; temp < contact->emails_nr; temp++) {
 734                         if (contact->emails_field[temp])
 735                                 free(contact->emails_field[temp]);
 736                         if (contact->emails_type[temp])
 737                                 free(contact->emails_type[temp]);
 738                 }
 739
 740                 free(contact->emails_field);
 741                 free(contact->emails_type);
 742         }
 743
 744         contact->emails_nr = contact->pref_email = 0;
 745
 746         /* XXX: Think, this is obsolete??? */
 747         contact->emails_field = contact->emails_type = 0;
 748
 749         result = 0;
 750
 751         return result;
 752 }
 753
 754 int gcal_contact_add_email_address(gcal_contact_t contact, const char *field,
 755                                    gcal_email_type type, int pref)
 756 {
 757         int result = -1;
 758
 759         if ((!contact) || (!field) || (type<0) || (type>=E_ITEMS_COUNT))
 760                 return result;
 761
 762         contact->emails_field = (char**) realloc(contact->emails_field,
 763                                                  (contact->emails_nr+1) *
 764                                                  sizeof(char*));
 765
 766         contact->emails_field[contact->emails_nr] = strdup(field);
 767
 768         contact->emails_type = (char**) realloc(contact->emails_type,
 769                                                 (contact->emails_nr+1) *
 770                                                 sizeof(char*));
 771
 772         contact->emails_type[contact->emails_nr] = strdup(gcal_email_type_str[type]);
 773
 774         if (pref)
 775                 contact->pref_email = contact->emails_nr;
 776
 777         contact->emails_nr++;
 778
 779         result = 0;
 780
 781         return result;
 782 }
 783
 784 int gcal_contact_set_email(gcal_contact_t contact, const char *pref_email)
 785 {
 786         int res;
 787         res = gcal_contact_add_email_address(contact, pref_email, E_HOME, 1);
 788         return res;
 789 }
 790
 791 int gcal_contact_set_url(gcal_contact_t contact, const char *field)
 792 {
 793         int result = -1;
 794
 795         if ((!contact) || (!field))
 796                 return result;
 797
 798         if (contact->common.edit_uri)
 799                 free(contact->common.edit_uri);
 800
 801         contact->common.edit_uri = strdup(field);
 802         if (contact->common.edit_uri)
 803                 result = 0;
 804
 805         return result;
 806 }
 807
 808
 809 int gcal_contact_set_id(gcal_contact_t contact, const char *field)
 810 {
 811         int result = -1;
 812
 813         if ((!contact) || (!field))
 814                 return result;
 815
 816         if (contact->common.id)
 817                 free(contact->common.id);
 818
 819         contact->common.id = strdup(field);
 820         if (contact->common.id)
 821                 result = 0;
 822
 823         return result;
 824 }
 825
 826
 827 int gcal_contact_set_etag(gcal_contact_t contact, const char *field)
 828 {
 829         int result = -1;
 830
 831         if ((!contact) || (!field))
 832                 return result;
 833
 834         if (contact->common.etag)
 835                 free(contact->common.etag);
 836
 837         contact->common.etag = strdup(field);
 838         if (contact->common.etag)
 839                 result = 0;
 840
 841         return result;
 842 }
 843
 844 int gcal_contact_delete_phone_numbers(gcal_contact_t contact)
 845 {
 846         int result = -1;
 847         int temp;
 848
 849         if (!contact)
 850                 return result;
 851
 852         if (contact->phone_numbers_nr > 0) {
 853                 for (temp = 0; temp < contact->phone_numbers_nr; temp++) {
 854                         if (contact->phone_numbers_field[temp])
 855                                 free(contact->phone_numbers_field[temp]);
 856                         if (contact->phone_numbers_type[temp])
 857                                 free(contact->phone_numbers_type[temp]);
 858                 }
 859
 860                 free(contact->phone_numbers_field);
 861                 free(contact->phone_numbers_type);
 862         }
 863
 864         contact->phone_numbers_nr = 0;
 865
 866         result = 0;
 867
 868         return result;
 869 }
 870
 871 int gcal_contact_add_phone_number(gcal_contact_t contact, const char *field,
 872                                   gcal_phone_type type)
 873 {
 874         int result = -1;
 875
 876         if ((!contact) || (!field) || (type<0) || (type>=P_ITEMS_COUNT))
 877                 return result;
 878
 879         contact->phone_numbers_field = (char**) realloc(contact->phone_numbers_field, (contact->phone_numbers_nr+1) * sizeof(char*));
 880         contact->phone_numbers_field[contact->phone_numbers_nr] = strdup(field);
 881
 882         contact->phone_numbers_type = (char**) realloc(contact->phone_numbers_type, (contact->phone_numbers_nr+1) * sizeof(char*));
 883         contact->phone_numbers_type[contact->phone_numbers_nr] = strdup(gcal_phone_type_str[type]);
 884
 885         contact->phone_numbers_nr++;
 886
 887         result = 0;
 888
 889         return result;
 890 }
 891
 892 int gcal_contact_set_phone(gcal_contact_t contact, const char *phone)
 893 {
 894         int res;
 895         res = gcal_contact_delete_phone_numbers(contact);
 896         if (res)
 897                 return res;
 898
 899         res = gcal_contact_add_phone_number(contact, phone, P_MOBILE);
 900         return res;
 901 }
 902
 903 int gcal_contact_delete_im(gcal_contact_t contact)
 904 {
 905         int result = -1;
 906         int temp;
 907
 908         if (!contact)
 909                 return result;
 910
 911         if (contact->im_nr > 0) {
 912                 for (temp = 0; temp < contact->im_nr; temp++) {
 913                         if (contact->im_protocol[temp])
 914                                 free(contact->im_protocol[temp]);
 915                         if (contact->im_address[temp])
 916                                 free(contact->im_address[temp]);
 917                         if (contact->im_type[temp])
 918                                 free(contact->im_type[temp]);
 919                 }
 920                 free(contact->im_protocol);
 921                 free(contact->im_address);
 922                 free(contact->im_type);
 923         }
 924
 925         contact->im_nr = contact->im_pref = 0;
 926
 927         result = 0;
 928
 929         return result;
 930 }
 931
 932 int gcal_contact_add_im(gcal_contact_t contact, const char *protcol,
 933                         const char *address, gcal_im_type type, int pref)
 934 {
 935         int result = -1;
 936
 937         if ((!contact) || (!protcol) || (!address) || (type<0) || (type>=I_ITEMS_COUNT))
 938                 return result;
 939
 940         contact->im_protocol = (char**) realloc(contact->im_protocol, (contact->im_nr+1) * sizeof(char*));
 941         contact->im_protocol[contact->im_nr] = strdup(protcol);
 942
 943         contact->im_address = (char**) realloc(contact->im_address, (contact->im_nr+1) * sizeof(char*));
 944         contact->im_address[contact->im_nr] = strdup(address);
 945
 946         contact->im_type = (char**) realloc(contact->im_type, (contact->im_nr+1) * sizeof(char*));
 947         contact->im_type[contact->im_nr] = strdup(gcal_im_type_str[type]);
 948
 949         if (pref)
 950                 contact->im_pref = contact->im_nr;
 951
 952         contact->im_nr++;
 953
 954         result = 0;
 955
 956         return result;
 957 }
 958
 959 int gcal_contact_set_address(gcal_contact_t contact, const char *field)
 960 {
 961         int result = -1;
 962
 963         if ((!contact) || (!field))
 964                 return result;
 965
 966         if (contact->post_address)
 967                 free(contact->post_address);
 968
 969         contact->post_address = strdup(field);
 970         if (contact->post_address)
 971                 result = 0;
 972
 973         return result;
 974 }
 975
 976 int gcal_contact_set_structured_address_nr(gcal_contact_t contact,
 977                                            gcal_address_type type)
 978 {
 979         int entry_nr, result = -1;
 980
 981         if (!contact || (type < 0) || (type >= A_ITEMS_COUNT))
 982                 return result;
 983
 984         entry_nr = contact->structured_address_nr;
 985         contact->structured_address_type = (char**) realloc(contact->structured_address_type, (entry_nr + 1) * sizeof(char*));
 986         contact->structured_address_type[entry_nr] = strdup(gcal_address_type_str[type]);
 987         contact->structured_address_nr++;
 988
 989         result = entry_nr;
 990
 991         return result;
 992 }
 993
 994 int gcal_contact_set_pref_structured_address(gcal_contact_t contact, int pref_address)
 995 {
 996         int result = -1;
 997
 998         if ((!contact) || (pref_address < 0))
 999                 return result;
1000
1001         contact->structured_address_pref = pref_address;
1002
1003         result = 0;
1004
1005         return result;
1006 }
1007
1008 int gcal_contact_set_structured_entry(gcal_structured_subvalues_t structured_entry,
1009                                       int structured_entry_nr,
1010                                       int structured_entry_count,
1011                                       const char *field_key,
1012                                       const char *field_value )
1013 {
1014         struct gcal_structured_subvalues *temp_structured_entry;
1015
1016         if (!structured_entry || (!field_value) || (!field_key) ||
1017             (structured_entry_nr < 0) ||
1018             (structured_entry_nr >= structured_entry_count))
1019                 return -1;
1020
1021         if (field_value == NULL)
1022                 field_value = "";
1023
1024         if (structured_entry->field_key == NULL) {
1025                 structured_entry->field_typenr = structured_entry_nr;
1026                 structured_entry->field_key = strdup(field_key);
1027                 structured_entry->field_value = strdup(field_value);
1028                 structured_entry->next_field = NULL;
1029                 return 0;
1030         }
1031
1032         for (temp_structured_entry = structured_entry; temp_structured_entry; temp_structured_entry = temp_structured_entry->next_field) {
1033                 if (!strcmp(temp_structured_entry->field_key,field_key) &&
1034                     (temp_structured_entry->field_typenr == structured_entry_nr)) {
1035                         if (temp_structured_entry->field_value != NULL) {
1036                                 free(temp_structured_entry->field_value);
1037                                 temp_structured_entry->field_value = strdup(field_value);
1038                                 return 0;
1039                         }
1040                 }
1041
1042                 if (temp_structured_entry->next_field == NULL) {
1043                         temp_structured_entry->next_field = (struct gcal_structured_subvalues *)malloc(sizeof(struct gcal_structured_subvalues));
1044                         temp_structured_entry = temp_structured_entry->next_field;
1045
1046                         temp_structured_entry->field_typenr = structured_entry_nr;
1047                         temp_structured_entry->field_key = strdup(field_key);
1048                         temp_structured_entry->field_value = strdup(field_value);
1049                         temp_structured_entry->next_field = NULL;
1050
1051                         return 0;
1052                 }
1053         }
1054         return -1;
1055 }
1056
1057 int gcal_contact_delete_structured_entry(gcal_structured_subvalues_t structured_entry,
1058                                          int *structured_entry_count,
1059                                          char ***structured_entry_type)
1060 {
1061         int i, result = -1;
1062         struct gcal_structured_subvalues *temp_structured_entry;
1063
1064         if (!structured_entry)
1065                 return result;
1066
1067         for (temp_structured_entry = structured_entry;
1068              temp_structured_entry != NULL;
1069              temp_structured_entry = temp_structured_entry->next_field) {
1070                 if (temp_structured_entry->field_typenr)
1071                         temp_structured_entry->field_typenr = 0;
1072                 if (temp_structured_entry->field_key)
1073                         free(temp_structured_entry->field_key);
1074                 if (temp_structured_entry->field_value)
1075                         free(temp_structured_entry->field_value);
1076         }
1077
1078         if (structured_entry_count && structured_entry_type) {
1079                 if ((*structured_entry_count) > 0) {
1080                         for (i = 0; i < (*structured_entry_count); i++)
1081                                 if ((*structured_entry_type)[i])
1082                                         free((*structured_entry_type)[i]);
1083                         free((*structured_entry_type));
1084                 }
1085
1086                 (*structured_entry_count) = 0;
1087         }
1088
1089         result = 0;
1090         return result;
1091 }
1092
1093 int gcal_contact_delete_groupMembership(gcal_contact_t contact)
1094 {
1095         int result = -1;
1096         int temp;
1097
1098         if (!contact)
1099                 return result;
1100
1101         if (contact->groupMembership_nr > 0) {
1102                 for (temp = 0; temp < contact->groupMembership_nr; temp++) {
1103                         if (contact->groupMembership[temp])
1104                                 free(contact->groupMembership[temp]);
1105                 }
1106
1107                 free(contact->groupMembership);
1108         }
1109
1110         contact->groupMembership_nr = 0;
1111         result = 0;
1112         return result;
1113 }
1114
1115 int gcal_contact_add_groupMembership(gcal_contact_t contact, const char *field)
1116 {
1117         int result = -1;
1118
1119         if ((!contact) || (!field))
1120                 return result;
1121
1122         contact->groupMembership = (char**) realloc(contact->groupMembership, (contact->groupMembership_nr+1) * sizeof(char*));
1123         contact->groupMembership[contact->groupMembership_nr] = strdup(field);
1124
1125         contact->groupMembership_nr++;
1126
1127         result = 0;
1128
1129         return result;
1130 }
1131
1132 int gcal_contact_set_profession(gcal_contact_t contact, const char *field)
1133 {
1134         int result = -1;
1135
1136         if ((!contact) || (!field))
1137                 return result;
1138
1139         if (contact->org_title)
1140                 free(contact->org_title);
1141
1142         contact->org_title = strdup(field);
1143         if (contact->org_title)
1144                 result = 0;
1145
1146         return result;
1147
1148 }
1149
1150 int gcal_contact_set_organization(gcal_contact_t contact, const char *field)
1151 {
1152         int result = -1;
1153
1154         if ((!contact) || (!field))
1155                 return result;
1156
1157         if (contact->org_name)
1158                 free(contact->org_name);
1159
1160         contact->org_name = strdup(field);
1161         if (contact->org_name)
1162                 result = 0;
1163
1164         return result;
1165 }
1166
1167 int gcal_contact_set_occupation(gcal_contact_t contact, const char *field)
1168 {
1169         int result = -1;
1170
1171         if ((!contact) || (!field))
1172                 return result;
1173
1174         if (contact->occupation)
1175                 free(contact->occupation);
1176
1177         contact->occupation = strdup(field);
1178         if (contact->occupation)
1179                 result = 0;
1180
1181         return result;
1182 }
1183
1184 int gcal_contact_set_content(gcal_contact_t contact, const char *field)
1185 {
1186         int result = -1;
1187
1188         if ((!contact) || (!field))
1189                 return result;
1190
1191         if (contact->content)
1192                 free(contact->content);
1193
1194         contact->content = strdup(field);
1195         if (contact->content)
1196                 result = 0;
1197
1198         return result;
1199 }
1200
1201 int gcal_contact_set_nickname(gcal_contact_t contact, const char *field)
1202 {
1203         int result = -1;
1204
1205         if ((!contact) || (!field))
1206                 return result;
1207
1208         if (contact->nickname)
1209                 free(contact->nickname);
1210
1211         contact->nickname = strdup(field);
1212         if (contact->nickname)
1213                 result = 0;
1214
1215         return result;
1216 }
1217
1218 int gcal_contact_set_photo(gcal_contact_t contact, const char *field,
1219                            int length)
1220 {
1221         int result = -1;
1222
1223         if ((!contact) || (!field))
1224                 return result;
1225
1226         if (contact->photo_data)
1227                 if (contact->photo_length > 1)
1228                         free(contact->photo_data);
1229
1230         if (!(contact->photo_data = malloc(length * sizeof(unsigned char))))
1231                 return result;
1232
1233         memcpy(contact->photo_data, field, length);
1234         contact->photo_length = length;
1235         result = 0;
1236
1237         return result;
1238 }
1239
1240 int gcal_contact_set_birthday(gcal_contact_t contact, const char *field)
1241 {
1242         int result = -1;
1243
1244         if ((!contact) || (!field))
1245                 return result;
1246
1247         if (contact->birthday)
1248                 free(contact->birthday);
1249
1250         contact->birthday = strdup(field);
1251         if (contact->birthday)
1252                 result = 0;
1253
1254         return result;
1255 }
1256
1257 int gcal_contact_set_homepage(gcal_contact_t contact, const char *field)
1258 {
1259         int result = -1;
1260
1261         if ((!contact) || (!field))
1262                 return result;
1263
1264         if (contact->homepage)
1265                 free(contact->homepage);
1266
1267         contact->homepage = strdup(field);
1268         if (contact->homepage)
1269                 result = 0;
1270
1271         return result;
1272 }
1273
1274 int gcal_contact_set_blog(gcal_contact_t contact, const char *field)
1275 {
1276         int result = -1;
1277
1278         if ((!contact) || (!field))
1279                 return result;
1280
1281         if (contact->blog)
1282                 free(contact->blog);
1283
1284         contact->blog = strdup(field);
1285         if (contact->blog)
1286                 result = 0;
1287
1288         return result;
1289 }