src/addrbook.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2001-2007 Match Grun and the Claws Mail team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   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, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 /* General functions for accessing address book files */
  21
  22 #include <glib.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <sys/stat.h>
  26 #include <math.h>
  27 #include <setjmp.h>
  28
  29 #include "xml.h"
  30 #include "mgutils.h"
  31 #include "addritem.h"
  32 #include "addrcache.h"
  33 #include "addrbook.h"
  34 #include "adbookbase.h"
  35
  36 #ifndef DEV_STANDALONE
  37 #include "prefs_gtk.h"
  38 #include "codeconv.h"
  39 #endif
  40
  41 #define ADDRBOOK_MAX_SEARCH_COUNT 1000
  42 #define ADDRBOOK_PREFIX           "addrbook-"
  43 #define ADDRBOOK_SUFFIX           ".xml"
  44 #define FILE_NUMDIGITS            6
  45
  46 #define ID_TIME_OFFSET            998000000
  47
  48 static void addrbook_print_book         ( AddressBookFile *book, FILE *stream );
  49
  50 /**
  51  * Create new address book
  52  * \return Address book.
  53  */
  54 AddressBookFile *addrbook_create_book()
  55 {
  56         AddressBookFile *book;
  57
  58         book = g_new0(AddressBookFile, 1);
  59         book->type = ADBOOKTYPE_BOOK;
  60         book->addressCache = addrcache_create();
  61         book->retVal = MGU_SUCCESS;
  62         book->path = NULL;
  63         book->fileName = NULL;
  64         book->maxValue = 0;
  65         book->tempList = NULL;
  66         book->tempHash = NULL;
  67         book->addressCache->modified = TRUE;
  68
  69         return book;
  70 }
  71
  72 /**
  73  * Specify name to be used
  74  * \param book  Address book.
  75  * \param value Name.
  76  */
  77 void addrbook_set_name(AddressBookFile *book, const gchar *value)
  78 {
  79         g_return_if_fail(book != NULL);
  80         addrcache_set_name(book->addressCache, value);
  81 }
  82
  83 gchar *addrbook_get_name(AddressBookFile *book)
  84 {
  85         g_return_val_if_fail(book != NULL, NULL);
  86         return addrcache_get_name(book->addressCache);
  87 }
  88
  89 /**
  90  * Specify path to address book file.
  91  * \param book  Address book.
  92  * \param value Path.
  93  */
  94 void addrbook_set_path(AddressBookFile *book, const gchar *value)
  95 {
  96         g_return_if_fail(book != NULL);
  97         book->path = mgu_replace_string(book->path, value);
  98         addrcache_set_dirty(book->addressCache, TRUE);
  99 }
 100
 101 /**
 102  * Specify filename to be used
 103  * \param book  Address book.
 104  * \param value Filename.
 105  */
 106 void addrbook_set_file(AddressBookFile *book, const gchar *value)
 107 {
 108         g_return_if_fail(book != NULL);
 109         book->fileName = mgu_replace_string(book->fileName, value);
 110         addrcache_set_dirty(book->addressCache, TRUE);
 111 }
 112
 113 gboolean addrbook_get_modified(AddressBookFile *book)
 114 {
 115         g_return_val_if_fail(book != NULL, FALSE);
 116         return book->addressCache->modified;
 117 }
 118
 119 gboolean addrbook_get_accessed(AddressBookFile *book)
 120 {
 121         g_return_val_if_fail(book != NULL, FALSE);
 122         return book->addressCache->accessFlag;
 123 }
 124
 125 /**
 126  * Specify address book as accessed.
 127  * \param book  Address book.
 128  * \param value Value.
 129  */
 130 void addrbook_set_accessed(AddressBookFile *book, const gboolean value)
 131 {
 132         g_return_if_fail(book != NULL);
 133         book->addressCache->accessFlag = value;
 134 }
 135
 136 gboolean addrbook_get_read_flag(AddressBookFile *book)
 137 {
 138         g_return_val_if_fail(book != NULL, FALSE);
 139         return book->addressCache->dataRead;
 140 }
 141
 142 gint addrbook_get_status(AddressBookFile *book)
 143 {
 144         g_return_val_if_fail(book != NULL, -1);
 145         return book->retVal;
 146 }
 147
 148 ItemFolder *addrbook_get_root_folder(AddressBookFile *book)
 149 {
 150         g_return_val_if_fail(book != NULL, NULL);
 151         return addrcache_get_root_folder(book->addressCache);
 152 }
 153
 154 GList *addrbook_get_list_folder(AddressBookFile *book)
 155 {
 156         g_return_val_if_fail(book != NULL, NULL);
 157         return addrcache_get_list_folder(book->addressCache);
 158 }
 159
 160 GList *addrbook_get_list_person(AddressBookFile *book)
 161 {
 162         g_return_val_if_fail(book != NULL, NULL);
 163         return addrcache_get_list_person(book->addressCache);
 164 }
 165
 166 gboolean addrbook_get_dirty(AddressBookFile *book)
 167 {
 168         g_return_val_if_fail(book != NULL, FALSE);
 169         return addrcache_get_dirty(book->addressCache);
 170 }
 171
 172 /**
 173  * Set address book as dirty (needs to be written to file).
 174  * \param book  Address book.
 175  * \param value Dirty flag.
 176  */
 177 void addrbook_set_dirty(AddressBookFile *book, const gboolean value)
 178 {
 179         g_return_if_fail(book != NULL);
 180         addrcache_set_dirty(book->addressCache, value);
 181 }
 182
 183 /**
 184  * Free address book.
 185  * \param book Address book.
 186  */
 187 void addrbook_free_book(AddressBookFile *book)
 188 {
 189         g_return_if_fail(book != NULL);
 190
 191         /* Clear cache */
 192         addrcache_free(book->addressCache);
 193
 194         /* Free up internal objects */
 195         g_free(book->path);
 196         g_free(book->fileName);
 197         g_list_free(book->tempList);
 198
 199         book->path = NULL;
 200         book->fileName = NULL;
 201         book->maxValue = 0;
 202         book->tempList = NULL;
 203         book->tempHash = NULL;
 204
 205         book->type = ADBOOKTYPE_NONE;
 206         book->addressCache = NULL;
 207         book->retVal = MGU_SUCCESS;
 208
 209         g_free(book);
 210 }
 211
 212 /**
 213  * Print address book header.
 214  * \param book   Address book.
 215  * \param stream Output stream.
 216  */
 217 static void addrbook_print_book(AddressBookFile *book, FILE *stream)
 218 {
 219         g_return_if_fail(book != NULL);
 220
 221         fprintf(stream, "AddressBook:\n");
 222         fprintf(stream, "\tpath : '%s'\n", book->path);
 223         fprintf(stream, "\tfile : '%s'\n", book->fileName);
 224         fprintf(stream, "\tstatus : %d\n", book->retVal );
 225         addrcache_print(book->addressCache, stream);
 226 }
 227
 228 /**
 229  * Dump entire address book traversing folders.
 230  * \param book   Address book.
 231  * \param stream Output stream.
 232  */
 233 void addrbook_dump_book(AddressBookFile *book, FILE *stream)
 234 {
 235         ItemFolder *folder;
 236
 237         g_return_if_fail(book != NULL);
 238
 239         addrbook_print_book(book, stream);
 240         folder = book->addressCache->rootFolder;
 241         addritem_print_item_folder(folder, stream);
 242 }
 243
 244 /**
 245  * Remove specified group from address book. Note that object should still
 246  * be freed.
 247  * Specify name to be used
 248  * \param book  Address book.
 249  * \param group Group to remove.
 250  * \param value Name.
 251  * \return Group, or NULL if not found.
 252  */
 253 ItemGroup *addrbook_remove_group(AddressBookFile *book, ItemGroup *group)
 254 {
 255         g_return_val_if_fail(book != NULL, NULL);
 256         return addrcache_remove_group(book->addressCache, group);
 257 }
 258
 259 /**
 260  * Remove specified person from address book. Note that object should still
 261  * be freed.
 262  * \param  book   Address book.
 263  * \param  person Person to remove.
 264  * \return Person, or NULL if not found.
 265  */
 266 ItemPerson *addrbook_remove_person(AddressBookFile *book, ItemPerson *person)
 267 {
 268         g_return_val_if_fail(book != NULL, NULL);
 269         return addrcache_remove_person(book->addressCache, person);
 270 }
 271
 272 /**
 273  * Remove specified email address in address book for specified person.
 274  * Note that object should still be freed.
 275  * \param  book   Address book.
 276  * \param  person Person.
 277  * \param  email  EMail to remove.
 278  * \return EMail object, or NULL if not found.
 279  */
 280 ItemEMail *addrbook_person_remove_email(AddressBookFile *book,
 281                                         ItemPerson *person, ItemEMail *email)
 282 {
 283         g_return_val_if_fail(book != NULL, NULL);
 284         return addrcache_person_remove_email(book->addressCache, person, email);
 285 }
 286
 287 /*
 288 * ***********************************************************************
 289 * Read/Write XML data file...
 290 * ===========================
 291 * Notes:
 292 * 1)    The address book is structured as follows:
 293 *
 294 *               address-book
 295 *                       person
 296 *                               address-list
 297 *                                       address
 298 *                               attribute-list
 299 *                                       attribute
 300 *                       group
 301 *                               member-list
 302 *                                       member
 303 *                       folder
 304 *                               item-list
 305 *                                       item
 306 *
 307 * 2)    This sequence of elements was chosen so that the most important
 308 *       elements (person and their email addresses) appear first.
 309 *
 310 * 3)    Groups then appear. When groups are loaded, person's email
 311 *       addresses have already been loaded and can be found.
 312 *
 313 * 4)    Finally folders are loaded. Any forward and backward references
 314 *       to folders, groups and persons in the folders are resolved after
 315 *       loading.
 316 *
 317 * ***********************************************************************
 318 */
 319
 320 /* Element tag names */
 321 #define AB_ELTAG_ADDRESS         "address"
 322 #define AB_ELTAG_ATTRIBUTE       "attribute"
 323 #define AB_ELTAG_ATTRIBUTE_LIST  "attribute-list"
 324 #define AB_ELTAG_ADDRESS_LIST    "address-list"
 325 #define AB_ELTAG_MEMBER          "member"
 326 #define AB_ELTAG_MEMBER_LIST     "member-list"
 327 #define AB_ELTAG_ITEM            "item"
 328 #define AB_ELTAG_ITEM_LIST       "item-list"
 329 #define AB_ELTAG_ADDRESS_BOOK    "address-book"
 330 #define AB_ELTAG_PERSON          "person"
 331 #define AB_ELTAG_GROUP           "group"
 332 #define AB_ELTAG_FOLDER          "folder"
 333
 334 /* Attribute tag names */
 335 #define AB_ATTAG_TYPE            "type"
 336 #define AB_ATTAG_UID             "uid"
 337 #define AB_ATTAG_NAME            "name"
 338 #define AB_ATTAG_REMARKS         "remarks"
 339 #define AB_ATTAG_FIRST_NAME      "first-name"
 340 #define AB_ATTAG_LAST_NAME       "last-name"
 341 #define AB_ATTAG_NICK_NAME       "nick-name"
 342 #define AB_ATTAG_COMMON_NAME     "cn"
 343 #define AB_ATTAG_ALIAS           "alias"
 344 #define AB_ATTAG_EMAIL           "email"
 345 #define AB_ATTAG_EID             "eid"
 346 #define AB_ATTAG_PID             "pid"
 347
 348 /* Attribute values */
 349 #define AB_ATTAG_VAL_PERSON      "person"
 350 #define AB_ATTAG_VAL_GROUP       "group"
 351 #define AB_ATTAG_VAL_FOLDER      "folder"
 352
 353 /**
 354  * Parse address item for person from XML file.
 355  * \param book   Address book.
 356  * \param file   XML file handle.
 357  * \param person Person.
 358  */
 359 static void addrbook_parse_address(AddressBookFile *book, XMLFile *file,
 360                                    ItemPerson *person)
 361 {
 362         GList *attr;
 363         gchar *name, *value;
 364         ItemEMail *email = NULL;
 365
 366         attr = xml_get_current_tag_attr(file);
 367         while (attr) {
 368                 name = ((XMLAttr *)attr->data)->name;
 369                 value = ((XMLAttr *)attr->data)->value;
 370                 if (!email)
 371                         email = addritem_create_item_email();
 372                 if (strcmp(name, AB_ATTAG_UID) == 0)
 373                         ADDRITEM_ID(email) = g_strdup(value);
 374                 else if (strcmp(name, AB_ATTAG_ALIAS) == 0)
 375                         ADDRITEM_NAME(email) = g_strdup(value);
 376                 else if (strcmp(name, AB_ATTAG_EMAIL) == 0)
 377                         email->address = g_strdup(value);
 378                 else if (strcmp(name, AB_ATTAG_REMARKS) == 0)
 379                         email->remarks = g_strdup(value);
 380                 attr = g_list_next(attr);
 381         }
 382         if (email) {
 383                 if (person) {
 384                         addrcache_person_add_email(book->addressCache, person,
 385                                                    email);
 386                 }
 387                 else {
 388                         addritem_free_item_email(email);
 389                         email = NULL;
 390                 }
 391         }
 392 }
 393
 394 /**
 395  * Parse list of email address for person from XML file.
 396  * \param book   Address book.
 397  * \param file   XML file handle.
 398  * \param person Person.
 399  */
 400 static void addrbook_parse_addr_list(AddressBookFile *book, XMLFile *file,
 401                                      ItemPerson *person)
 402 {
 403         GList *attr;
 404         guint prev_level;
 405
 406         for (;;) {
 407                 prev_level = file->level;
 408                 if (xml_parse_next_tag(file)) {
 409                         longjmp(book->jumper, 1);
 410                 }
 411                 if (file->level < prev_level) return;
 412                 if (xml_compare_tag(file, AB_ELTAG_ADDRESS)) {
 413                         attr = xml_get_current_tag_attr(file);
 414                         addrbook_parse_address(book, file, person);
 415                         addrbook_parse_addr_list(book, file, person);
 416                 }
 417         }
 418 }
 419
 420 /**
 421  * Parse attribute for person from XML file.
 422  * \param book   Address book.
 423  * \param file   XML file handle.
 424  * \param person Person.
 425  */
 426 static void addrbook_parse_attribute(XMLFile *file, ItemPerson *person)
 427 {
 428         GList *attr;
 429         gchar *name, *value;
 430         gchar *element;
 431         UserAttribute *uAttr = NULL;
 432
 433         attr = xml_get_current_tag_attr(file);
 434         while (attr) {
 435                 name = ((XMLAttr *)attr->data)->name;
 436                 value = ((XMLAttr *)attr->data)->value;
 437                 if (!uAttr) uAttr = addritem_create_attribute();
 438                 if (strcmp(name, AB_ATTAG_UID) == 0)
 439                         addritem_attrib_set_id(uAttr, value);
 440                 else if (strcmp(name, AB_ATTAG_NAME) == 0)
 441                         addritem_attrib_set_name(uAttr, value);
 442                 attr = g_list_next(attr);
 443         }
 444
 445         element = xml_get_element(file);
 446         addritem_attrib_set_value(uAttr, element);
 447         g_free(element);
 448
 449         if (uAttr) {
 450                 if (person) {
 451                         addritem_person_add_attribute(person, uAttr);
 452                 }
 453                 else {
 454                         addritem_free_attribute(uAttr);
 455                         uAttr = NULL;
 456                 }
 457         }
 458 }
 459
 460 /**
 461  * Parse list of attributes for person from XML file.
 462  * \param book   Address book.
 463  * \param file   XML file handle.
 464  * \param person Person.
 465  */
 466 static void addrbook_parse_attr_list(AddressBookFile *book, XMLFile *file,
 467                                      ItemPerson *person)
 468 {
 469         GList *attr;
 470         guint prev_level;
 471
 472         for (;;) {
 473                 prev_level = file->level;
 474                 if (xml_parse_next_tag(file)) {
 475                         longjmp( book->jumper, 1 );
 476                 }
 477                 if (file->level < prev_level) return;
 478                 if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE)) {
 479                         attr = xml_get_current_tag_attr(file);
 480                         addrbook_parse_attribute(file, person);
 481                         addrbook_parse_attr_list(book, file, person);
 482                 }
 483         }
 484 }
 485
 486 /**
 487  * Parse person from XML file.
 488  * \param book Address book.
 489  * \param file XML file handle.
 490  */
 491 static void addrbook_parse_person(AddressBookFile *book, XMLFile *file)
 492 {
 493         GList *attr;
 494         gchar *name, *value;
 495         ItemPerson *person = NULL;
 496
 497         attr = xml_get_current_tag_attr(file);
 498         while (attr) {
 499                 name = ((XMLAttr *)attr->data)->name;
 500                 value = ((XMLAttr *)attr->data)->value;
 501                 if (!person)
 502                         person = addritem_create_item_person();
 503                 if (strcmp(name, AB_ATTAG_UID) == 0)
 504                         ADDRITEM_ID(person) = g_strdup(value);
 505                 else if (strcmp(name, AB_ATTAG_FIRST_NAME) == 0)
 506                         person->firstName = g_strdup(value);
 507                 else if (strcmp(name, AB_ATTAG_LAST_NAME) == 0)
 508                         person->lastName = g_strdup(value);
 509                 else if (strcmp(name, AB_ATTAG_NICK_NAME) == 0)
 510                         person->nickName = g_strdup(value);
 511                 else if (strcmp(name, AB_ATTAG_COMMON_NAME) == 0)
 512                         ADDRITEM_NAME(person) = g_strdup(value);
 513                 attr = g_list_next(attr);
 514         }
 515         if (xml_parse_next_tag(file)) { /* Consume closing tag */
 516                 longjmp(book->jumper, 1);
 517         }
 518         if (xml_compare_tag(file, AB_ELTAG_ADDRESS_LIST)) {
 519                 addrbook_parse_addr_list(book, file, person);
 520                 if (person) {
 521                         addrcache_hash_add_person(book->addressCache, person);
 522                 }
 523         }
 524         if (xml_parse_next_tag(file)) { /* Consume closing tag */
 525                 longjmp(book->jumper, 1);
 526         }
 527         if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE_LIST)) {
 528                 addrbook_parse_attr_list(book, file, person);
 529         }
 530 }
 531
 532 /**
 533  * Parse group member from XML file.
 534  * \param book  Address book.
 535  * \param file  XML file handle.
 536  * \param group Group.
 537  */
 538 static void addrbook_parse_member(AddressBookFile *book, XMLFile *file,
 539                                   ItemGroup *group)
 540 {
 541         GList *attr;
 542         gchar *name, *value;
 543         gchar *eid = NULL;
 544         /* gchar *pid = NULL; */
 545         ItemEMail *email = NULL;
 546
 547         attr = xml_get_current_tag_attr(file);
 548         while (attr) {
 549                 name = ((XMLAttr *)attr->data)->name;
 550                 value = ((XMLAttr *)attr->data)->value;
 551                 if( strcmp( name, AB_ATTAG_EID ) == 0 )
 552                         eid = g_strdup( value );
 553                 attr = g_list_next(attr);
 554         }
 555         /* email = addrcache_get_email( book->addressCache, pid, eid ); */
 556         email = addrcache_get_email(book->addressCache, eid);
 557         g_free(eid);
 558         if (email) {
 559                 if (group) {
 560                         addrcache_group_add_email(book->addressCache, group,
 561                                                   email);
 562                 }
 563                 else {
 564                         addritem_free_item_email(email);
 565                         email = NULL;
 566                 }
 567         }
 568 }
 569
 570 /**
 571  * Parse list of group members from XML file.
 572  * \param book  Address book.
 573  * \param file  XML file handle.
 574  * \param group Group.
 575  */
 576 static void addrbook_parse_member_list(AddressBookFile *book, XMLFile *file,
 577                                        ItemGroup *group)
 578 {
 579         GList *attr;
 580         guint prev_level;
 581
 582         for (;;) {
 583                 prev_level = file->level;
 584                 if (xml_parse_next_tag(file)) {
 585                         longjmp(book->jumper, 1);
 586                 }
 587                 if (file->level < prev_level)
 588                         return;
 589                 if (xml_compare_tag(file, AB_ELTAG_MEMBER)) {
 590                         attr = xml_get_current_tag_attr(file);
 591                         addrbook_parse_member(book, file, group);
 592                         addrbook_parse_member_list(book, file, group);
 593                 }
 594                 else {
 595                         attr = xml_get_current_tag_attr(file);
 596                 }
 597         }
 598 }
 599
 600 /**
 601  * Parse group object from XML file.
 602  * \param book Address book.
 603  * \param file XML file handle.
 604  */
 605 static void addrbook_parse_group(AddressBookFile *book, XMLFile *file)
 606 {
 607         GList *attr;
 608         gchar *name, *value;
 609         ItemGroup *group = NULL;
 610
 611         attr = xml_get_current_tag_attr(file);
 612         while (attr) {
 613                 name = ((XMLAttr *)attr->data)->name;
 614                 value = ((XMLAttr *)attr->data)->value;
 615                 if (!group)
 616                         group = addritem_create_item_group();
 617                 if (strcmp(name, AB_ATTAG_UID) == 0)
 618                         ADDRITEM_ID(group) = g_strdup(value);
 619                 else if (strcmp(name, AB_ATTAG_NAME) == 0)
 620                         ADDRITEM_NAME(group) = g_strdup(value);
 621                 else if (strcmp(name, AB_ATTAG_REMARKS) == 0)
 622                         group->remarks = g_strdup(value);
 623                 attr = g_list_next(attr);
 624         }
 625         if (xml_parse_next_tag(file)) { /* Consume closing tag */
 626                 longjmp(book->jumper, 1);
 627         }
 628         if (xml_compare_tag(file, AB_ELTAG_MEMBER_LIST)) {
 629                 if (group) {
 630                         addrcache_hash_add_group(book->addressCache, group);
 631                 }
 632                 addrbook_parse_member_list(book, file, group);
 633         }
 634 }
 635
 636 /**
 637  * Parse folder item from XML file.
 638  * \param book   Address book.
 639  * \param file   XML file handle.
 640  * \param folder Folder.
 641  */
 642 static void addrbook_parse_folder_item(AddressBookFile *book, XMLFile *file,
 643                                        ItemFolder *folder)
 644 {
 645         GList *attr;
 646         gchar *name, *value;
 647         gchar *uid = NULL;
 648
 649         attr = xml_get_current_tag_attr(file);
 650         while (attr) {
 651                 name = ((XMLAttr *)attr->data)->name;
 652                 value = ((XMLAttr *)attr->data)->value;
 653                 if (strcmp(name, AB_ATTAG_UID) == 0) {
 654                         uid = g_strdup(value);
 655                 }
 656                 attr = g_list_next(attr);
 657         }
 658         if (folder) {
 659                 if (uid) {
 660                         folder->listItems = g_list_append(folder->listItems, uid);
 661                 }
 662         }
 663 }
 664
 665 /**
 666  * Parse list of folder items from XML file.
 667  * \param book   Address book.
 668  * \param file   XML file handle.
 669  * \param folder Folder.
 670  */
 671 static void addrbook_parse_folder_list(AddressBookFile *book, XMLFile *file,
 672                                        ItemFolder *folder)
 673 {
 674         GList *attr;
 675         guint prev_level;
 676
 677         for (;;) {
 678                 prev_level = file->level;
 679                 if (xml_parse_next_tag(file)) {
 680                         longjmp(book->jumper, 1);
 681                 }
 682                 if (file->level < prev_level)
 683                         return;
 684                 if (xml_compare_tag(file, AB_ELTAG_ITEM)) {
 685                         attr = xml_get_current_tag_attr(file);
 686                         addrbook_parse_folder_item(book, file, folder);
 687                         addrbook_parse_folder_list(book, file, folder);
 688                 }
 689                 else {
 690                         attr = xml_get_current_tag_attr(file);
 691                 }
 692         }
 693 }
 694
 695 /**
 696  * Parse folder from XML file.
 697  * \param book Address book.
 698  * \param file XML file handle.
 699  */
 700 static void addrbook_parse_folder(AddressBookFile *book, XMLFile *file)
 701 {
 702         GList *attr;
 703         gchar *name, *value;
 704         ItemFolder *folder = NULL;
 705
 706         attr = xml_get_current_tag_attr(file);
 707         while (attr) {
 708                 name = ((XMLAttr *)attr->data)->name;
 709                 value = ((XMLAttr *)attr->data)->value;
 710                 if (!folder)
 711                         folder = addritem_create_item_folder();
 712                 if (strcmp(name, AB_ATTAG_UID) == 0)
 713                         ADDRITEM_ID(folder) = g_strdup(value);
 714                 else if (strcmp(name, AB_ATTAG_NAME) == 0)
 715                         ADDRITEM_NAME(folder) = g_strdup(value);
 716                 else if (strcmp(name, AB_ATTAG_REMARKS) == 0)
 717                         folder->remarks = g_strdup(value);
 718                 attr = g_list_next(attr);
 719         }
 720         if (xml_parse_next_tag(file)) { /* Consume closing tag */
 721                 longjmp(book->jumper, 1);
 722         }
 723         if (xml_compare_tag(file, AB_ELTAG_ITEM_LIST)) {
 724                 if (folder) {
 725                         if (addrcache_hash_add_folder(book->addressCache,
 726                                                       folder)) {
 727                                 book->tempList = g_list_append(book->tempList,
 728                                                                folder);
 729                                 /* We will resolve folder later */
 730                                 ADDRITEM_PARENT(folder) = NULL;
 731                         }
 732                 }
 733                 addrbook_parse_folder_list(book, file, folder);
 734         }
 735 }
 736
 737 /**
 738  * Read address book (DOM) tree from file.
 739  * \param  book Address book.
 740  * \param  file XML file handle.
 741  * \return <i>TRUE</i> if data read successfully, <i>FALSE</i> if error
 742  *         reading data.
 743  */
 744 static gboolean addrbook_read_tree(AddressBookFile *book, XMLFile *file)
 745 {
 746         gboolean retVal;
 747         GList *attr;
 748         gchar *name, *value;
 749
 750         book->retVal = MGU_BAD_FORMAT;
 751         if (xml_get_dtd(file))
 752                 return FALSE;
 753         if (xml_parse_next_tag(file))
 754                 longjmp(book->jumper, 1);
 755         if (!xml_compare_tag(file, AB_ELTAG_ADDRESS_BOOK))
 756                 return FALSE;
 757
 758         attr = xml_get_current_tag_attr(file);
 759         while (attr) {
 760                 name = ((XMLAttr *)attr->data)->name;
 761                 value = ((XMLAttr *)attr->data)->value;
 762                 if (strcmp( name, AB_ATTAG_NAME) == 0)
 763                         addrbook_set_name( book, value );
 764                 attr = g_list_next( attr );
 765         }
 766
 767         retVal = TRUE;
 768         for (;;) {
 769                 if (!file->level)
 770                         break;
 771                 /* Get next item tag (person, group or folder) */
 772                 if (xml_parse_next_tag(file))
 773                         longjmp( book->jumper, 1 );
 774
 775                 if (xml_compare_tag(file, AB_ELTAG_PERSON))
 776                         addrbook_parse_person(book, file);
 777                 else if (xml_compare_tag(file, AB_ELTAG_GROUP))
 778                         addrbook_parse_group(book, file);
 779                 else if (xml_compare_tag(file, AB_ELTAG_FOLDER))
 780                         addrbook_parse_folder(book, file);
 781         }
 782         if (retVal) book->retVal = MGU_SUCCESS;
 783                 return retVal;
 784 }
 785
 786 /**
 787  * Resolve folder items callback function.
 788  * \param key   Table key.
 789  * \param value Reference to object contained in folder.
 790  * \param data  Reference to address book.
 791  */
 792 static void addrbook_res_items_vis(gpointer key, gpointer value, gpointer data)
 793 {
 794         AddressBookFile *book = data;
 795         AddrItemObject *obj = (AddrItemObject *) value;
 796         ItemFolder *rootFolder = book->addressCache->rootFolder;
 797         if (obj->parent == NULL) {
 798                 if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON) {
 799                         rootFolder->listPerson = g_list_append(rootFolder->listPerson,
 800                                                                obj);
 801                         ADDRITEM_PARENT(obj) = ADDRITEM_OBJECT(rootFolder);
 802                 }
 803                 else if (ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP) {
 804                         rootFolder->listGroup = g_list_append(rootFolder->listGroup,
 805                                                               obj);
 806                         ADDRITEM_PARENT(obj) = ADDRITEM_OBJECT(rootFolder);
 807                 }
 808         }
 809 }
 810
 811 /**
 812  * Resolve folder items. Lists of UID's are replaced with pointers to
 813  * data items.
 814  * \param  book Address book.
 815  */
 816 static void addrbook_resolve_folder_items(AddressBookFile *book)
 817 {
 818         GList *nodeFolder = NULL;
 819         GList *listRemove = NULL;
 820         GList *node = NULL;
 821         ItemFolder *rootFolder = book->addressCache->rootFolder;
 822         nodeFolder = book->tempList;
 823
 824         while (nodeFolder) {
 825                 ItemFolder *folder = nodeFolder->data;
 826                 listRemove = NULL;
 827                 node = folder->listItems;
 828                 while (node) {
 829                         gchar *uid = node->data;
 830                         AddrItemObject *aio = addrcache_get_object(book->addressCache,
 831                                                                    uid);
 832                         if (aio) {
 833                                 if (aio->type == ITEMTYPE_FOLDER) {
 834                                         ItemFolder *item = (ItemFolder *) aio;
 835                                         folder->listFolder = g_list_append(folder->listFolder, item);
 836                                         ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
 837                                         addrcache_hash_add_folder(book->addressCache, folder);
 838                                 }
 839                                 else if (aio->type == ITEMTYPE_PERSON) {
 840                                         ItemPerson *item = (ItemPerson *) aio;
 841                                         folder->listPerson = g_list_append(folder->listPerson, item);
 842                                         ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
 843                                 }
 844                                 else if (aio->type == ITEMTYPE_GROUP) {
 845                                         ItemGroup *item = (ItemGroup *) aio;
 846                                         folder->listGroup = g_list_append(folder->listGroup, item);
 847                                         ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
 848                                 }
 849                                 /* Replace data with pointer to item */
 850                                 g_free(uid);
 851                                 node->data = aio;
 852                         }
 853                         else { /* Not found, append to remove list. */
 854                                 listRemove = g_list_append(listRemove, uid);
 855                         }
 856                         node = g_list_next(node);
 857                 }
 858                 rootFolder->listFolder = g_list_append(rootFolder->listFolder,
 859                                                        folder);
 860                 /* Process remove list */
 861                 node = listRemove;
 862                 while (node) {
 863                         gchar *uid = node->data;
 864                         folder->listItems = g_list_remove(folder->listItems,
 865                                                           uid);
 866                         g_free(uid);
 867                         node = g_list_next(node);
 868                 }
 869                 g_list_free(listRemove);
 870                 nodeFolder = g_list_next(nodeFolder);
 871         }
 872         /* Remove folders with parents. */
 873         listRemove = NULL;
 874         node = rootFolder->listFolder;
 875         while (node) {
 876                 ItemFolder *folder = (ItemFolder *) node->data;
 877                 if (ADDRITEM_PARENT(folder))
 878                         /* Remove folders with parents */
 879                         listRemove = g_list_append(listRemove, folder);
 880                 else /* Add to root folder */
 881                         ADDRITEM_PARENT(folder) = ADDRITEM_OBJECT(book->addressCache->rootFolder);
 882
 883                 node = g_list_next( node );
 884         }
 885         /* Process remove list */
 886         node = listRemove;
 887         while (node) {
 888                 rootFolder->listFolder = g_list_remove(rootFolder->listFolder,
 889                                                        node->data);
 890                 node = g_list_next(node);
 891         }
 892         g_list_free(listRemove);
 893
 894         /* Move all unparented persons and groups into root folder */
 895         g_hash_table_foreach(book->addressCache->itemHash,
 896                              addrbook_res_items_vis, book);
 897
 898         /* Free up some more */
 899         nodeFolder = book->tempList;
 900         while (nodeFolder) {
 901                 ItemFolder *folder = nodeFolder->data;
 902                 g_list_free(folder->listItems);
 903                 folder->listItems = NULL;
 904                 nodeFolder = g_list_next(nodeFolder);
 905         }
 906         g_list_free(book->tempList);
 907         book->tempList = NULL;
 908 }
 909
 910 /**
 911  * Read address book.
 912  * \param  book Address book.
 913  * \return Status code.
 914  */
 915 gint addrbook_read_data(AddressBookFile *book)
 916 {
 917         XMLFile *file = NULL;
 918         gchar *fileSpec = NULL;
 919
 920         g_return_val_if_fail(book != NULL, -1);
 921
 922         /*
 923         g_print( "...addrbook_read_data :%s:\t:%s:\n", book->fileName,
 924                 addrcache_get_name( book->addressCache ) );
 925         */
 926
 927         fileSpec = g_strconcat(book->path, G_DIR_SEPARATOR_S,
 928                                book->fileName, NULL);
 929         book->retVal = MGU_OPEN_FILE;
 930         addrcache_clear(book->addressCache);
 931         book->addressCache->modified = FALSE;
 932         book->addressCache->accessFlag = FALSE;
 933         file = xml_open_file(fileSpec);
 934         g_free(fileSpec);
 935         if (file) {
 936                 book->tempList = NULL;
 937                 /* Trap for parsing errors. */
 938                 if (setjmp( book->jumper)) {
 939                         xml_close_file(file);
 940                         return book->retVal;
 941                 }
 942                 addrbook_read_tree(book, file);
 943                 xml_close_file(file);
 944                 /* Resolve folder items */
 945                 addrbook_resolve_folder_items(book);
 946                 book->tempList = NULL;
 947                 book->addressCache->modified = FALSE;
 948                 book->addressCache->dataRead = TRUE;
 949                 addrcache_set_dirty(book->addressCache, FALSE);
 950         }
 951         return book->retVal;
 952 }
 953
 954 /**
 955  * Write start element to file.
 956  * \param fp   File handle.
 957  * \param lvl  Indent level.
 958  * \param name Element name.
 959  */
 960 static int addrbook_write_elem_s(FILE *fp, gint lvl, gchar *name)
 961 {
 962         gint i;
 963         for (i = 0; i < lvl; i++)
 964                 if (fputs("  ", fp) == EOF)
 965                         return -1;
 966         if (fputs("<", fp) == EOF)
 967                 return -1;
 968         if (fputs(name, fp) == EOF)
 969                 return -1;
 970
 971         return 0;
 972 }
 973
 974 /**
 975  * Write end element to file.
 976  * \param fp   File handle.
 977  * \param lvl  Indent level.
 978  * \param name Element name.
 979  */
 980 static int addrbook_write_elem_e(FILE *fp, gint lvl, gchar *name)
 981 {
 982         gint i;
 983         for(i = 0; i < lvl; i++)
 984                 if (fputs("  ", fp) == EOF)
 985                         return -1;
 986         if (fputs("</", fp) == EOF)
 987                 return -1;
 988         if (fputs(name, fp) == EOF)
 989                 return -1;
 990         if (fputs(">\n", fp) == EOF)
 991                 return -1;
 992
 993         return 0;
 994 }
 995
 996 /**
 997  * Write attribute name/value pair to file.
 998  * \param fp    File handle.
 999  * \param name  Attribute name.
1000  * \param value Attribute value.
1001  */
1002 static int addrbook_write_attr(FILE *fp, gchar *name, gchar *value)
1003 {
1004         if (fputs(" ", fp) == EOF)
1005                 return -1;
1006         if (fputs(name, fp) == EOF)
1007                 return -1;
1008         if (fputs("=\"", fp) == EOF)
1009                 return -1;
1010         if (xml_file_put_escape_str(fp, value) < 0)
1011                 return -1;
1012         if (fputs("\"", fp) == EOF)
1013                 return -1;
1014
1015         return 0;
1016 }
1017
1018 typedef struct _HashLoopData {
1019         FILE *fp;
1020         gboolean error;
1021 } HashLoopData;
1022
1023 /**
1024  * Write person and associated addresses and attributes to file.
1025  * file hash table visitor function.
1026  * \param key   Table key.
1027  * \param value Reference to person.
1028  * \param data  File pointer.
1029  */
1030 static void addrbook_write_item_person_vis(gpointer key, gpointer value,
1031                                            gpointer d)
1032 {
1033         AddrItemObject *obj = (AddrItemObject *) value;
1034         HashLoopData *data = (HashLoopData *)d;
1035         FILE *fp = data->fp;
1036         GList *node;
1037
1038         if (!obj)
1039                 return;
1040         if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON) {
1041                 ItemPerson *person = (ItemPerson *) value;
1042                 if (person) {
1043                         if (addrbook_write_elem_s(fp, 1, AB_ELTAG_PERSON) < 0)
1044                                 data->error = TRUE;
1045                         if (addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(person)) < 0)
1046                                 data->error = TRUE;
1047                         if (addrbook_write_attr(fp, AB_ATTAG_FIRST_NAME, person->firstName) < 0)
1048                                 data->error = TRUE;
1049                         if (addrbook_write_attr(fp, AB_ATTAG_LAST_NAME, person->lastName) < 0)
1050                                 data->error = TRUE;
1051                         if (addrbook_write_attr(fp, AB_ATTAG_NICK_NAME, person->nickName) < 0)
1052                                 data->error = TRUE;
1053                         if (addrbook_write_attr(fp, AB_ATTAG_COMMON_NAME, ADDRITEM_NAME(person)) < 0)
1054                                 data->error = TRUE;
1055                         if (fputs(" >\n", fp) == EOF)
1056                                 data->error = TRUE;
1057
1058                         /* Output email addresses */
1059                         if (addrbook_write_elem_s(fp, 2, AB_ELTAG_ADDRESS_LIST) < 0)
1060                                 data->error = TRUE;
1061                         if (fputs(">\n", fp) == EOF)
1062                                 data->error = TRUE;
1063                         node = person->listEMail;
1064                         while (node) {
1065                                 ItemEMail *email = node->data;
1066                                 if (addrbook_write_elem_s(fp, 3, AB_ELTAG_ADDRESS) < 0)
1067                                         data->error = TRUE;
1068                                 if (addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(email)) < 0)
1069                                         data->error = TRUE;
1070                                 if (addrbook_write_attr(fp, AB_ATTAG_ALIAS, ADDRITEM_NAME(email)) < 0)
1071                                         data->error = TRUE;
1072                                 if (addrbook_write_attr(fp, AB_ATTAG_EMAIL, email->address) < 0)
1073                                         data->error = TRUE;
1074                                 if (addrbook_write_attr(fp, AB_ATTAG_REMARKS, email->remarks) < 0)
1075                                         data->error = TRUE;
1076                                 if (fputs(" />\n", fp) == EOF)
1077                                         data->error = TRUE;
1078                                 node = g_list_next(node);
1079                         }
1080                         if (addrbook_write_elem_e(fp, 2, AB_ELTAG_ADDRESS_LIST) < 0)
1081                                 data->error = TRUE;
1082
1083                         /* Output user attributes */
1084                         if (addrbook_write_elem_s(fp, 2, AB_ELTAG_ATTRIBUTE_LIST) < 0)
1085                                 data->error = TRUE;
1086                         if (fputs(">\n", fp) == EOF)
1087                                 data->error = TRUE;
1088                         node = person->listAttrib;
1089                         while (node) {
1090                                 UserAttribute *attrib = node->data;
1091                                 if (addrbook_write_elem_s(fp, 3, AB_ELTAG_ATTRIBUTE) < 0)
1092                                         data->error = TRUE;
1093                                 if (addrbook_write_attr(fp, AB_ATTAG_UID, attrib->uid) < 0)
1094                                         data->error = TRUE;
1095                                 if (addrbook_write_attr(fp, AB_ATTAG_NAME, attrib->name) < 0)
1096                                         data->error = TRUE;
1097                                 if (fputs(" >", fp) == EOF)
1098                                         data->error = TRUE;
1099                                 if (xml_file_put_escape_str(fp, attrib->value) < 0)
1100                                         data->error = TRUE;
1101                                 if (addrbook_write_elem_e(fp, 0, AB_ELTAG_ATTRIBUTE) < 0)
1102                                         data->error = TRUE;
1103                                 node = g_list_next(node);
1104                         }
1105                         if (addrbook_write_elem_e(fp, 2, AB_ELTAG_ATTRIBUTE_LIST) < 0)
1106                                 data->error = TRUE;
1107                         if (addrbook_write_elem_e(fp, 1, AB_ELTAG_PERSON) < 0)
1108                                 data->error = TRUE;
1109                 }
1110         }
1111 }
1112
1113 /**
1114  * Write group and associated references to addresses to file.
1115  * file hash table visitor function.
1116  * \param key   Table key.
1117  * \param value Reference to group.
1118  * \param data  File pointer.
1119  */
1120 static void addrbook_write_item_group_vis(gpointer key, gpointer value,
1121                                           gpointer d)
1122 {
1123         AddrItemObject *obj = (AddrItemObject *) value;
1124         HashLoopData *data = (HashLoopData *)d;
1125         FILE *fp = data->fp;
1126
1127         GList *node;
1128
1129         if (!obj)
1130                 return;
1131         if (ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP) {
1132                 ItemGroup *group = (ItemGroup *) value;
1133                 if (group) {
1134                         if (addrbook_write_elem_s(fp, 1, AB_ELTAG_GROUP) < 0)
1135                                 data->error = TRUE;
1136                         if (addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(group)) < 0)
1137                                 data->error = TRUE;
1138                         if (addrbook_write_attr(fp, AB_ATTAG_NAME, ADDRITEM_NAME(group)) < 0)
1139                                 data->error = TRUE;
1140                         if (addrbook_write_attr(fp, AB_ATTAG_REMARKS, group->remarks) < 0)
1141                                 data->error = TRUE;
1142                         if (fputs(" >\n", fp) == EOF)
1143                                 data->error = TRUE;
1144
1145                         /* Output email address links */
1146                         if (addrbook_write_elem_s(fp, 2, AB_ELTAG_MEMBER_LIST) < 0)
1147                                 data->error = TRUE;
1148                         if (fputs(">\n", fp) == EOF)
1149                                 data->error = TRUE;
1150                         node = group->listEMail;
1151                         while (node) {
1152                                 ItemEMail *email = node->data;
1153                                 ItemPerson *person = (ItemPerson *) ADDRITEM_PARENT(email);
1154                                 if (addrbook_write_elem_s(fp, 3, AB_ELTAG_MEMBER) < 0)
1155                                         data->error = TRUE;
1156                                 if (addrbook_write_attr(fp, AB_ATTAG_PID, ADDRITEM_ID(person)) < 0)
1157                                         data->error = TRUE;
1158                                 if (addrbook_write_attr(fp, AB_ATTAG_EID, ADDRITEM_ID(email)) < 0)
1159                                         data->error = TRUE;
1160                                 if (fputs(" />\n", fp) == EOF)
1161                                         data->error = TRUE;
1162                                 node = g_list_next(node);
1163                         }
1164                         if (addrbook_write_elem_e(fp, 2, AB_ELTAG_MEMBER_LIST) < 0)
1165                                 data->error = TRUE;
1166                         if (addrbook_write_elem_e(fp, 1, AB_ELTAG_GROUP) < 0)
1167                                 data->error = TRUE;
1168                 }
1169         }
1170 }
1171
1172 /**
1173  * Write folder and associated references to addresses to file.
1174  * file hash table visitor function.
1175  * \param key   Table key.
1176  * \param value Reference to folder.
1177  * \param data  File pointer.
1178  */
1179 static void addrbook_write_item_folder_vis(gpointer key, gpointer value,
1180                                            gpointer d)
1181 {
1182         AddrItemObject *obj = (AddrItemObject *) value;
1183         HashLoopData *data = (HashLoopData *)d;
1184         FILE *fp = data->fp;
1185         GList *node;
1186
1187         if (!obj)
1188                 return;
1189         if (ADDRITEM_TYPE(obj) == ITEMTYPE_FOLDER) {
1190                 ItemFolder *folder = (ItemFolder *) value;
1191                 if (folder) {
1192                         if (addrbook_write_elem_s(fp, 1, AB_ELTAG_FOLDER) < 0)
1193                                 data->error = TRUE;
1194                         if (addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(folder)) < 0)
1195                                 data->error = TRUE;
1196                         if (addrbook_write_attr(fp, AB_ATTAG_NAME, ADDRITEM_NAME(folder)) < 0)
1197                                 data->error = TRUE;
1198                         if (addrbook_write_attr(fp, AB_ATTAG_REMARKS, folder->remarks) < 0)
1199                                 data->error = TRUE;
1200                         if (fputs(" >\n", fp) == EOF)
1201                                 data->error = TRUE;
1202                         if (addrbook_write_elem_s(fp, 2, AB_ELTAG_ITEM_LIST) < 0)
1203                                 data->error = TRUE;
1204                         if (fputs(">\n", fp) == EOF)
1205                                 data->error = TRUE;
1206
1207                         /* Output persons */
1208                         node = folder->listPerson;
1209                         while (node) {
1210                                 ItemPerson *item = node->data;
1211                                 if (addrbook_write_elem_s(fp, 3, AB_ELTAG_ITEM) < 0)
1212                                         data->error = TRUE;
1213                                 if (addrbook_write_attr(fp, AB_ATTAG_TYPE,  AB_ATTAG_VAL_PERSON) < 0)
1214                                         data->error = TRUE;
1215                                 if (addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(item)) < 0)
1216                                         data->error = TRUE;
1217                                 if (fputs(" />\n", fp) == EOF)
1218                                         data->error = TRUE;
1219                                 node = g_list_next(node);
1220                         }
1221
1222                         /* Output groups */
1223                         node = folder->listGroup;
1224                         while (node) {
1225                                 ItemGroup *item = node->data;
1226                                 if (addrbook_write_elem_s(fp, 3, AB_ELTAG_ITEM) < 0)
1227                                         data->error = TRUE;
1228                                 if (addrbook_write_attr(fp, AB_ATTAG_TYPE, AB_ATTAG_VAL_GROUP) < 0)
1229                                         data->error = TRUE;
1230                                 if (addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(item)) < 0)
1231                                         data->error = TRUE;
1232                                 if (fputs(" />\n", fp) == EOF)
1233                                         data->error = TRUE;
1234                                 node = g_list_next(node);
1235                         }
1236
1237                         /* Output folders */
1238                         node = folder->listFolder;
1239                         while (node) {
1240                                 ItemFolder *item = node->data;
1241                                 if (addrbook_write_elem_s(fp, 3, AB_ELTAG_ITEM) < 0)
1242                                         data->error = TRUE;
1243                                 if (addrbook_write_attr(fp, AB_ATTAG_TYPE, AB_ATTAG_VAL_FOLDER) < 0)
1244                                         data->error = TRUE;
1245                                 if (addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(item)) < 0)
1246                                         data->error = TRUE;
1247                                 if (fputs(" />\n", fp) == EOF)
1248                                         data->error = TRUE;
1249                                 node = g_list_next(node);
1250                         }
1251                         if (addrbook_write_elem_e(fp, 2, AB_ELTAG_ITEM_LIST) < 0)
1252                                 data->error = TRUE;
1253                         if (addrbook_write_elem_e(fp, 1, AB_ELTAG_FOLDER) < 0)
1254                                 data->error = TRUE;
1255                 }
1256         }
1257 }
1258
1259 /**
1260  * Output address book data to specified file.
1261  * \param  book Address book.
1262  * \param  newFile Filename of new file (in book's filepath).
1263  * \return Status code.
1264  */
1265 static gint addrbook_write_to(AddressBookFile *book, gchar *newFile)
1266 {
1267         FILE *fp;
1268         gchar *fileSpec;
1269         HashLoopData data;
1270 #ifndef DEV_STANDALONE
1271         PrefFile *pfile;
1272 #endif
1273
1274         g_return_val_if_fail(book != NULL, -1);
1275         g_return_val_if_fail(newFile != NULL, -1);
1276
1277         fileSpec = g_strconcat(book->path, G_DIR_SEPARATOR_S, newFile, NULL);
1278
1279         book->retVal = MGU_OPEN_FILE;
1280 #ifdef DEV_STANDALONE
1281         fp = g_fopen(fileSpec, "wb");
1282         g_free(fileSpec);
1283         if (fp) {
1284                 if (fputs("<?xml version=\"1.0\" ?>\n", fp) == EOF) {
1285                         book->retVal = MGU_ERROR_WRITE;
1286                         return book->retVal;
1287                 }
1288 #else
1289         pfile = prefs_write_open(fileSpec);
1290         g_free(fileSpec);
1291         if (pfile) {
1292                 fp = pfile->fp;
1293                 if (fprintf( fp, "<?xml version=\"1.0\" encoding=\"%s\" ?>\n", CS_INTERNAL ) < 0)
1294                         goto fail;
1295 #endif
1296                 if (addrbook_write_elem_s(fp, 0, AB_ELTAG_ADDRESS_BOOK) < 0)
1297                         goto fail;
1298                 if (addrbook_write_attr(fp, AB_ATTAG_NAME,
1299                                     addrcache_get_name(book->addressCache)) < 0)
1300                         goto fail;
1301                 if (fputs(" >\n", fp) == EOF)
1302                         goto fail;
1303
1304                 /* Output all persons */
1305                 data.fp = fp;
1306                 data.error = FALSE;
1307
1308                 g_hash_table_foreach(book->addressCache->itemHash,
1309                                      addrbook_write_item_person_vis, &data);
1310                 if (data.error)
1311                         goto fail;
1312
1313                 /* Output all groups */
1314                 g_hash_table_foreach(book->addressCache->itemHash,
1315                                      addrbook_write_item_group_vis, &data);
1316
1317                 if (data.error)
1318                         goto fail;
1319
1320                 /* Output all folders */
1321                 g_hash_table_foreach(book->addressCache->itemHash,
1322                                      addrbook_write_item_folder_vis, &data);
1323
1324                 if (data.error)
1325                         goto fail;
1326
1327                 if (addrbook_write_elem_e(fp, 0, AB_ELTAG_ADDRESS_BOOK) < 0)
1328                         goto fail;
1329
1330                 book->retVal = MGU_SUCCESS;
1331 #ifdef DEV_STANDALONE
1332                 fclose(fp);
1333 #else
1334                 if (prefs_file_close( pfile ) < 0)
1335                         book->retVal = MGU_ERROR_WRITE;
1336 #endif
1337         }
1338
1339         fileSpec = NULL;
1340         return book->retVal;
1341 fail:
1342         g_warning("error writing AB\n");
1343         book->retVal = MGU_ERROR_WRITE;
1344         if (pfile)
1345                 prefs_file_close_revert( pfile );
1346         return book->retVal;
1347 }
1348
1349 /**
1350  * Output address book data to original file.
1351  * \param  book Address book.
1352  * \return Status code.
1353  */
1354 gint addrbook_save_data(AddressBookFile *book)
1355 {
1356         g_return_val_if_fail(book != NULL, -1);
1357
1358         book->retVal = MGU_NO_FILE;
1359         if (book->fileName == NULL || *book->fileName == '\0')
1360                 return book->retVal;
1361         if (book->path == NULL || *book->path == '\0')
1362                 return book->retVal;
1363
1364         addrbook_write_to(book, book->fileName);
1365         if (book->retVal == MGU_SUCCESS)
1366                 addrcache_set_dirty(book->addressCache, FALSE);
1367         return book->retVal;
1368 }
1369
1370 /*
1371  * **********************************************************************
1372  * Address book edit interface functions.
1373  * **********************************************************************
1374  */
1375
1376 /**
1377  * Hash table callback function for simple deletion of hashtable entries.
1378  * \param  key   Table key (will be freed).
1379  * \param  value Value stored in table.
1380  * \param  data  User data.
1381  * \return <i>TRUE</i> to indicate that entry freed.
1382  */
1383 static gboolean addrbook_free_simple_hash_vis(gpointer *key, gpointer *value,
1384                                               gpointer *data)
1385 {
1386         g_free(key);
1387         key = NULL;
1388         value = NULL;
1389         return TRUE;
1390 }
1391
1392 /**
1393  * Update address book email list for specified person. Note: The existing
1394  * email addresses are replaced with the new addresses. Any references to
1395  * old addresses in the groups are re-linked to the new addresses. All old
1396  * addresses linked to the person are removed.
1397  * \param book      Address book.
1398  * \param person    Person to update.
1399  * \param listEMail List of new email addresses.
1400  */
1401 void addrbook_update_address_list(AddressBookFile *book, ItemPerson *person,
1402                                   GList *listEMail)
1403 {
1404         GList *node;
1405         GList *listDelete;
1406         GList *listGroup;
1407
1408         g_return_if_fail(book != NULL);
1409         g_return_if_fail(person != NULL);
1410
1411         /* Get groups where person's existing email addresses are listed */
1412         listGroup = addrcache_get_group_for_person(book->addressCache, person);
1413         if (listGroup) {
1414                 GHashTable *hashEMail;
1415                 GHashTable *hashEMailAlias;
1416                 GList *nodeGrp;
1417
1418                 /* Load hash table with new address entries */
1419                 hashEMail = g_hash_table_new(g_str_hash, g_str_equal);
1420                 hashEMailAlias = g_hash_table_new(g_str_hash, g_str_equal);
1421                 node = listEMail;
1422                 while (node) {
1423                         ItemEMail *email = node->data;
1424                         gchar *addr = g_strdup(email->address);
1425                         gchar *alias = email->obj.name ;
1426                         g_strdown(addr);
1427                         if (!g_hash_table_lookup(hashEMail, addr)) {
1428                                 g_hash_table_insert(hashEMail, addr, email);
1429                         }
1430                         if (*alias != '\0' && ! g_hash_table_lookup(hashEMailAlias,
1431                             alias))
1432                                 g_hash_table_insert(hashEMailAlias, alias, email);
1433
1434                         node = g_list_next(node);
1435                 }
1436
1437                 /* Re-parent new addresses to existing groups, where email address match. */
1438                 nodeGrp = listGroup;
1439                 while (nodeGrp) {
1440                         ItemGroup *group = (ItemGroup *) nodeGrp->data;
1441                         GList *groupEMail = group->listEMail;
1442                         GList *nodeGrpEM;
1443                         GList *listRemove = NULL;
1444
1445                         /* Process each email item linked to group */
1446                         nodeGrpEM = groupEMail;
1447                         while (nodeGrpEM) {
1448                                 ItemEMail *emailGrp = (ItemEMail *) nodeGrpEM->data;
1449
1450                                 if (ADDRITEM_PARENT(emailGrp) == ADDRITEM_OBJECT(person)) {
1451                                         /* Found an email address for this person */
1452                                         ItemEMail *emailNew = NULL;
1453                                         gchar *addr = g_strdup(emailGrp->address);
1454                                         gchar *alias = emailGrp->obj.name;
1455                                         g_strdown(addr);
1456                                         emailNew = (ItemEMail *)
1457                                                 g_hash_table_lookup(hashEMail, addr);
1458                                         g_free( addr );
1459                                         /* If no match by e-mail, try to match by e-mail alias */
1460                                         if (!emailNew && *alias != '\0') {
1461                                                 emailNew = (ItemEMail *)
1462                                                         g_hash_table_lookup(hashEMailAlias, alias);
1463                                         }
1464
1465                                         if (emailNew)
1466                                                 /* Point to this entry */
1467                                                 nodeGrpEM->data = emailNew;
1468                                         else if (g_hash_table_size(hashEMail)==1)
1469                                                 /* If the person has just one e-mail address, then
1470                                                    change e-mail address in group list */
1471                                                 nodeGrpEM->data = listEMail->data;
1472                                         else
1473                                                 /* Mark for removal */
1474                                                 listRemove = g_list_append(listRemove, emailGrp);
1475                                 }
1476                                 /* Move on to next email link */
1477                                 nodeGrpEM = g_list_next(nodeGrpEM);
1478                         }
1479
1480                         /* Process all removed links in current group */
1481                         nodeGrpEM = listRemove;
1482                         while (nodeGrpEM) {
1483                                 ItemEMail *emailGrp = nodeGrpEM->data;
1484                                 groupEMail = g_list_remove(groupEMail, emailGrp);
1485                                 nodeGrpEM = g_list_next(nodeGrpEM);
1486                         }
1487
1488                         g_list_free(listRemove);
1489
1490                         /* Move on to next group */
1491                         nodeGrp = g_list_next(nodeGrp);
1492
1493                 }
1494                 /* Clear hash table */
1495                 g_hash_table_foreach_remove(hashEMail, (GHRFunc)
1496                                             addrbook_free_simple_hash_vis, NULL);
1497                 g_hash_table_destroy(hashEMail);
1498                 hashEMail = NULL;
1499                 g_hash_table_destroy(hashEMailAlias);
1500                 hashEMailAlias = NULL;
1501                 g_list_free(listGroup);
1502                 listGroup = NULL;
1503         }
1504         /* Remove old addresses from person and cache */
1505         listDelete = NULL;
1506         node = person->listEMail;
1507         while (node) {
1508                 ItemEMail *email = node->data;
1509
1510                 if (addrcache_person_remove_email(book->addressCache, person, email))
1511                         addrcache_remove_email(book->addressCache, email);
1512
1513                 listDelete = g_list_append(listDelete, email);
1514                 node = person->listEMail;
1515         }
1516         /* Add new address entries */
1517         node = listEMail;
1518         while (node) {
1519                 ItemEMail *email = node->data;
1520
1521                 if (ADDRITEM_ID(email) == NULL)
1522                         /* Allocate an ID for new address */
1523                         addrcache_id_email(book->addressCache, email);
1524
1525                 addrcache_person_add_email( book->addressCache, person, email );
1526                 node = g_list_next( node );
1527         }
1528
1529         addrcache_set_dirty(book->addressCache, TRUE);
1530
1531         /* Free up memory */
1532         g_list_free(listEMail);
1533         listEMail = NULL;
1534
1535         node = listDelete;
1536         while (node) {
1537                 ItemEMail *email = node->data;
1538
1539                 addritem_free_item_email(email);
1540                 node = g_list_next(node);
1541         }
1542         g_list_free(listDelete);
1543         listDelete = NULL;
1544
1545 }
1546
1547 /**
1548  * Create person object and add person with specified address data to address
1549  * book. Note: A new person is created with specified list of email addresses.
1550  * All objects inserted into address book.
1551  *
1552  * \param  book      Address book.
1553  * \param  folder    Parent folder where to add person, or <i>NULL</i> for
1554  *                   root folder.
1555  * \param  listEMail List of new email addresses to associate with person.
1556  * \return Person object created.
1557  */
1558 ItemPerson *addrbook_add_address_list(AddressBookFile *book, ItemFolder *folder,
1559                                       GList *listEMail)
1560 {
1561         ItemPerson *person;
1562         ItemFolder *f = folder;
1563         GList *node;
1564
1565         g_return_val_if_fail(book != NULL, NULL);
1566
1567         if (!f)
1568                 f = book->addressCache->rootFolder;
1569         person = addritem_create_item_person();
1570         addrcache_id_person(book->addressCache, person);
1571         addrcache_folder_add_person(book->addressCache, f, person);
1572
1573         node = listEMail;
1574         while (node) {
1575                 ItemEMail *email = node->data;
1576                 if (ADDRITEM_ID(email) == NULL)
1577                         addrcache_id_email(book->addressCache, email);
1578
1579                 addrcache_person_add_email(book->addressCache, person, email);
1580                 node = g_list_next(node);
1581         }
1582         return person;
1583 }
1584
1585 /**
1586  * Build available email list visitor function.
1587  * \param  key   Table key.
1588  * \param  value Value stored in table.
1589  * \param  data  Reference to address book.
1590  */
1591 static void addrbook_build_avail_email_vis(gpointer key, gpointer value,
1592                                            gpointer data)
1593 {
1594         AddrItemObject *obj = (AddrItemObject *) value;
1595
1596         if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON) {
1597                 AddressBookFile *book = data;
1598                 ItemPerson *person = (ItemPerson *) obj;
1599                 GList *node = person->listEMail;
1600                 while (node) {
1601                         ItemEMail *email = node->data;
1602                         /* gchar *newKey = g_strdup( ADDRITEM_ID(email) ); */
1603
1604                         if (!g_hash_table_lookup(book->tempHash,
1605                                                  ADDRITEM_ID(email)))
1606                                 book->tempList = g_list_append(book->tempList, email);
1607
1608                         node = g_list_next(node);
1609                 }
1610         }
1611 }
1612
1613 /**
1614  * Return link list of available email items that have not already been linked
1615  * to groups. Note that the list contains references to items and should be
1616  * <code>g_free()</code> when done. Do <b>*NOT*</b> attempt to used the
1617  * <code>addrbook_free_xxx()<code> functions... this will destroy the
1618  * addressbook data!
1619  *
1620  * \param  book  Address book.
1621  * \param  group Group to process.
1622  * \return List of items, or <i>NULL</i> if none.
1623  */
1624 GList *addrbook_get_available_email_list(AddressBookFile *book, ItemGroup *group)
1625 {
1626         GList *list = NULL;
1627         GHashTable *table;
1628
1629         g_return_val_if_fail(book != NULL, NULL);
1630
1631         /* Load hash table with group email entries */
1632         table = g_hash_table_new(g_str_hash, g_str_equal);
1633         if (group) {
1634                 list = group->listEMail;
1635                 while (list) {
1636                         ItemEMail *email = list->data;
1637                         g_hash_table_insert(table, ADDRITEM_ID(email), email);
1638                         list = g_list_next(list);
1639                 }
1640         }
1641
1642         /* Build list of available email addresses which exclude those already in groups */
1643         book->tempList = NULL;
1644         book->tempHash = table;
1645         g_hash_table_foreach(book->addressCache->itemHash,
1646                              addrbook_build_avail_email_vis, book);
1647         list = book->tempList;
1648         book->tempList = NULL;
1649         book->tempHash = NULL;
1650
1651         /* Clear hash table */
1652         g_hash_table_destroy(table);
1653         table = NULL;
1654
1655         return list;
1656 }
1657
1658 /**
1659  * Update address book email list for specified group. Note: The existing email
1660  * addresses are replaced with the new addresses. Any references to old addresses
1661  * in the groups are re-linked to the new addresses. All old addresses linked to
1662  * the person are removed.
1663  *
1664  * \param book      Address book.
1665  * \param group     Group to process.
1666  * \param listEMail List of email items. This should <b>*NOT*</b> be
1667  *                  <code>g_free()</code> when done.
1668  */
1669 void addrbook_update_group_list(AddressBookFile *book, ItemGroup *group,
1670                                 GList *listEMail)
1671 {
1672         GList *oldData;
1673
1674         g_return_if_fail(book != NULL);
1675         g_return_if_fail(group != NULL);
1676
1677         addrcache_set_dirty(book->addressCache, TRUE);
1678
1679         /* Remember old list */
1680         oldData = group->listEMail;
1681         group->listEMail = listEMail;
1682         mgu_clear_list(oldData);
1683         oldData = NULL;
1684 }
1685
1686 /**
1687  * Create group object and add with specifed list of email addresses to
1688  * address book. Note: The existing email addresses are replaced with the new
1689  * addresses. Any references to old addresses in the groups are re-linked to
1690  * the new addresses. All old addresses linked to the person are removed.
1691  *
1692  * \param  book      Address book.
1693  * \param  folder    Parent folder where to add group, or <i>NULL</i> for
1694  *                   root folder.
1695  * \param  listEMail List of email items. This should <b>*NOT*</b> be
1696  *                  <code>g_free()</code> when done.
1697  * \return Group object created.
1698  */
1699 ItemGroup *addrbook_add_group_list(AddressBookFile *book, ItemFolder *folder,
1700                                    GList *listEMail)
1701 {
1702         ItemGroup *group = NULL;
1703         ItemFolder *f = folder;
1704
1705         g_return_val_if_fail(book != NULL, NULL);
1706
1707         if (!f)
1708                 f = book->addressCache->rootFolder;
1709         group = addritem_create_item_group();
1710         addrcache_id_group(book->addressCache, group);
1711         addrcache_folder_add_group(book->addressCache, f, group);
1712         group->listEMail = listEMail;
1713         return group;
1714 }
1715
1716 /**
1717  * Create a new folder and add to address book.
1718  * \param  book   Address book.
1719  * \param  folder Parent folder where to add folder, or <i>NULL</i> for
1720  *                root folder.
1721  * \return Folder that was created. This should <b>*NOT*</b> be
1722  *         <code>g_free()</code> when done.
1723  */
1724 ItemFolder *addrbook_add_new_folder(AddressBookFile *book, ItemFolder *parent)
1725 {
1726         g_return_val_if_fail(book != NULL, NULL);
1727         return addrcache_add_new_folder( book->addressCache, parent );
1728 }
1729
1730 /**
1731  * Update address book attribute list for specified person. Note: The existing
1732  * attributes are replaced with the new addresses. All old attributes linked
1733  * to the person are removed.
1734  *
1735  * \param book       Address book.
1736  * \param person     Person to receive attributes.
1737  * \param listAttrib New list of attributes.
1738  */
1739 void addrbook_update_attrib_list(AddressBookFile *book, ItemPerson *person,
1740                                  GList *listAttrib)
1741 {
1742         GList *node;
1743         GList *oldData;
1744
1745         g_return_if_fail(book != NULL);
1746         g_return_if_fail(person != NULL);
1747
1748         /* Remember old list */
1749         oldData = person->listAttrib;
1750
1751         /* Attach new address list to person. */
1752         node = listAttrib;
1753         while (node) {
1754                 UserAttribute *attrib = node->data;
1755                 if (attrib->uid == NULL) {
1756                         /* Allocate an ID */
1757                         addrcache_id_attribute(book->addressCache, attrib);
1758                 }
1759                 node = g_list_next(node);
1760         }
1761         person->listAttrib = listAttrib;
1762         addrcache_set_dirty(book->addressCache, TRUE);
1763
1764         /* Free up old data */
1765         addritem_free_list_attribute(oldData);
1766         oldData = NULL;
1767 }
1768
1769 /**
1770  * Add attribute data for specified person to address book. Note: Only
1771  * attributes are inserted into address book.
1772  * \param book       Address book.
1773  * \param person     Person to receive attributes.
1774  * \param listAttrib List of attributes.
1775  */
1776 void addrbook_add_attrib_list( AddressBookFile *book, ItemPerson *person, GList *listAttrib ) {
1777         GList *node;
1778
1779         g_return_if_fail( book != NULL );
1780         g_return_if_fail( person != NULL );
1781
1782         node = listAttrib;
1783         while( node ) {
1784                 UserAttribute *attrib = node->data;
1785                 if( attrib->uid == NULL ) {
1786                         addrcache_id_attribute( book->addressCache, attrib );
1787                 }
1788                 addritem_person_add_attribute( person, attrib );
1789                 node = g_list_next( node );
1790         }
1791         addrcache_set_dirty( book->addressCache, TRUE );
1792 }
1793
1794 #define WORK_BUFLEN     1024
1795 #define ADDRBOOK_DIGITS "0123456789"
1796
1797 /**
1798  * Return list of existing address book files.
1799  * \param  book Address book.
1800  * \return List of files (as strings).
1801  */
1802 GList *addrbook_get_bookfile_list(AddressBookFile *book) {
1803         gchar *adbookdir;
1804         GDir *dir;
1805         const gchar *dir_name;
1806         struct stat statbuf;
1807         gchar buf[WORK_BUFLEN];
1808         gchar numbuf[WORK_BUFLEN];
1809         gint len, lenpre, lensuf, lennum;
1810         long int val, maxval;
1811         GList *fileList = NULL;
1812
1813         g_return_val_if_fail(book != NULL, NULL);
1814
1815         if (book->path == NULL || *book->path == '\0') {
1816                 book->retVal = MGU_NO_PATH;
1817                 return NULL;
1818         }
1819
1820         strcpy(buf, book->path);
1821         len = strlen(buf);
1822         if (len > 0) {
1823                 if (buf[len-1] != G_DIR_SEPARATOR) {
1824                         buf[len] = G_DIR_SEPARATOR;
1825                         buf[++len] = '\0';
1826                 }
1827         }
1828
1829         adbookdir = g_strdup(buf);
1830         strcat(buf, ADDRBOOK_PREFIX);
1831
1832         if( ( dir = g_dir_open( adbookdir, 0, NULL ) ) == NULL ) {
1833                 book->retVal = MGU_OPEN_DIRECTORY;
1834                 g_free(adbookdir);
1835                 return NULL;
1836         }
1837
1838         lenpre = strlen(ADDRBOOK_PREFIX);
1839         lensuf = strlen(ADDRBOOK_SUFFIX);
1840         lennum = FILE_NUMDIGITS + lenpre;
1841         maxval = -1;
1842
1843         while( ( dir_name = g_dir_read_name( dir ) ) != NULL ) {
1844                 gchar *endptr = NULL;
1845                 gint i;
1846                 gboolean flg;
1847
1848                 strcpy(buf, adbookdir);
1849                 strcat( buf, dir_name );
1850                 stat(buf, &statbuf);
1851                 if (S_ISREG(statbuf.st_mode)) {
1852                         if (strncmp(
1853                                 dir_name,
1854                                 ADDRBOOK_PREFIX, lenpre) == 0)
1855                         {
1856                                 if (strncmp(
1857                                         (dir_name) + lennum,
1858                                         ADDRBOOK_SUFFIX, lensuf) == 0)
1859                                 {
1860                                         strncpy(numbuf,
1861                                                 (dir_name) + lenpre,
1862                                                 FILE_NUMDIGITS);
1863                                         numbuf[FILE_NUMDIGITS] = '\0';
1864                                         flg = TRUE;
1865                                         for(i = 0; i < FILE_NUMDIGITS; i++) {
1866                                                 if(!strchr(ADDRBOOK_DIGITS, numbuf[i])) {
1867                                                         flg = FALSE;
1868                                                         break;
1869                                                 }
1870                                         }
1871                                         if (flg) {
1872                                                 /* Get value */
1873                                                 val = strtol(numbuf, &endptr, 10);
1874                                                 if (endptr  && val > -1) {
1875                                                         if (val > maxval) maxval = val;
1876                                                         fileList = g_list_append(
1877                                                                 fileList,
1878                                                                 g_strdup(dir_name));
1879                                                 }
1880                                         }
1881                                 }
1882                         }
1883                 }
1884         }
1885         g_dir_close( dir );
1886         g_free(adbookdir);
1887
1888         book->maxValue = maxval;
1889         book->retVal = MGU_SUCCESS;
1890         return fileList;
1891 }
1892
1893 /**
1894  * Return file name for specified file number.
1895  * \param  fileNum File number.
1896  * \return File name, or <i>NULL</i> if file number too large. Should be
1897  *         <code>g_free()</code> when done.
1898  */
1899 gchar *addrbook_gen_new_file_name(gint fileNum) {
1900         gchar fmt[30];
1901         gchar buf[WORK_BUFLEN];
1902         gint n = fileNum;
1903         long int nmax;
1904
1905         if (n < 1)
1906                 n = 1;
1907         nmax = -1 + (long int) pow(10, FILE_NUMDIGITS);
1908         if (fileNum > nmax)
1909                 return NULL;
1910         g_snprintf(fmt, sizeof(fmt), "%%s%%0%dd%%s", FILE_NUMDIGITS);
1911         g_snprintf(buf, sizeof(buf), fmt, ADDRBOOK_PREFIX, n, ADDRBOOK_SUFFIX);
1912         return g_strdup(buf);
1913 }
1914
1915 /*
1916  * **********************************************************************
1917  * Address book test functions...
1918  * **********************************************************************
1919  */
1920
1921 /**
1922  * Attempt to parse list of email address from file.
1923  * \param book Address book.
1924  * \param file XML file handle.
1925  */
1926 static void addrbook_chkparse_addr_list( AddressBookFile *book, XMLFile *file ){
1927         guint prev_level;
1928         GList *attr;
1929
1930         for (;;) {
1931                 prev_level = file->level;
1932                 if (xml_parse_next_tag(file))
1933                         longjmp(book->jumper, 1);
1934                 if (file->level < prev_level)
1935                         return;
1936                 attr = xml_get_current_tag_attr(file);
1937                 /* addrbook_show_attribs( attr ); */
1938                 if (xml_compare_tag(file, AB_ELTAG_ADDRESS))
1939                         addrbook_chkparse_addr_list(book, file);
1940         }
1941 }
1942
1943 /**
1944  * Attempt to parse attributes for person address from file.
1945  * \param book Address book.
1946  * \param file XML file handle.
1947  */
1948 static void addrbook_chkparse_attribute(AddressBookFile *book, XMLFile *file)
1949 {
1950         GList *attr;
1951         gchar *element;
1952
1953         attr = xml_get_current_tag_attr(file);
1954         /* addrbook_show_attribs( attr ); */
1955         element = xml_get_element(file);
1956         /* g_print( "\t\tattrib value : %s\n", element ); */
1957 }
1958
1959 /**
1960  * Attempt to parse list of attributes for person address from file.
1961  * \param book Address book.
1962  * \param file XML file handle.
1963  */
1964 static void addrbook_chkparse_attr_list(AddressBookFile *book, XMLFile *file)
1965 {
1966         guint prev_level;
1967
1968         for (;;) {
1969                 prev_level = file->level;
1970                 if (xml_parse_next_tag(file))
1971                         longjmp(book->jumper, 1);
1972                 if (file->level < prev_level)
1973                         return;
1974                 if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE)) {
1975                         addrbook_chkparse_attribute(book, file);
1976                         addrbook_chkparse_attr_list(book, file);
1977                 }
1978         }
1979 }
1980
1981 /**
1982  * Attempt to parse person from file.
1983  * \param book Address book.
1984  * \param file XML file handle.
1985  */
1986 static void addrbook_chkparse_person(AddressBookFile *book, XMLFile *file)
1987 {
1988         GList *attr;
1989
1990         attr = xml_get_current_tag_attr(file);
1991         /* addrbook_show_attribs( attr ); */
1992         if (xml_parse_next_tag(file)) /* Consume closing tag */
1993                 longjmp(book->jumper, 1);
1994
1995         if (xml_compare_tag(file, AB_ELTAG_ADDRESS_LIST))
1996                 addrbook_chkparse_addr_list(book, file);
1997
1998         if (xml_parse_next_tag(file))   /* Consume closing tag */
1999                 longjmp(book->jumper, 1);
2000
2001         if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE_LIST))
2002                 addrbook_chkparse_attr_list(book, file);
2003 }
2004
2005 /**
2006  * Attempt to parse list of members from file.
2007  * \param book Address book.
2008  * \param file XML file handle.
2009  */
2010 static void addrbook_chkparse_member_list(AddressBookFile *book, XMLFile *file)
2011 {
2012         GList *attr;
2013         guint prev_level;
2014
2015         for (;;) {
2016                 prev_level = file->level;
2017                 if (xml_parse_next_tag(file))
2018                         longjmp(book->jumper, 1);
2019
2020                 if (file->level < prev_level)
2021                         return;
2022
2023                 if (xml_compare_tag(file, AB_ELTAG_MEMBER)) {
2024                         attr = xml_get_current_tag_attr(file);
2025                         /* addrbook_show_attribs( attr ); */
2026                         addrbook_chkparse_member_list(book, file);
2027                 }
2028                 else {
2029                         attr = xml_get_current_tag_attr(file);
2030                         /* addrbook_show_attribs( attr ); */
2031                 }
2032         }
2033 }
2034
2035 /**
2036  * Attempt to parse group from file.
2037  * \param book Address book.
2038  * \param file XML file handle.
2039  */
2040 static void addrbook_chkparse_group(AddressBookFile *book, XMLFile *file)
2041 {
2042         GList *attr;
2043
2044         attr = xml_get_current_tag_attr(file);
2045         /* addrbook_show_attribs( attr ); */
2046         if (xml_parse_next_tag(file))   /* Consume closing tag */
2047                 longjmp(book->jumper, 1);
2048
2049         if (xml_compare_tag(file, AB_ELTAG_MEMBER_LIST))
2050                 addrbook_chkparse_member_list(book, file);
2051 }
2052
2053 /**
2054  * Attempt to parse list of folders from file.
2055  * \param book Address book.
2056  * \param file XML file handle.
2057  */
2058 static void addrbook_chkparse_folder_list(AddressBookFile *book, XMLFile *file)
2059 {
2060         GList *attr;
2061         guint prev_level;
2062
2063         for (;;) {
2064                 prev_level = file->level;
2065                 if (xml_parse_next_tag(file))
2066                         longjmp(book->jumper, 1);
2067
2068                 if (file->level < prev_level)
2069                         return;
2070
2071                 if (xml_compare_tag(file, AB_ELTAG_ITEM)) {
2072                         attr = xml_get_current_tag_attr(file);
2073                         /* addrbook_show_attribs( attr ); */
2074                         addrbook_chkparse_folder_list(book, file);
2075                 }
2076                 else {
2077                         attr = xml_get_current_tag_attr(file);
2078                         /* addrbook_show_attribs( attr ); */
2079                 }
2080         }
2081 }
2082
2083 /**
2084  * Attempt to parse a folder from file.
2085  * \param book Address book.
2086  * \param file XML file handle.
2087  */
2088 static void addrbook_chkparse_folder(AddressBookFile *book, XMLFile *file)
2089 {
2090         GList *attr;
2091
2092         attr = xml_get_current_tag_attr(file);
2093         /* addrbook_show_attribs( attr ); */
2094         if (xml_parse_next_tag(file))   /* Consume closing tag */
2095                 longjmp(book->jumper, 1);
2096
2097         if (xml_compare_tag(file, AB_ELTAG_ITEM_LIST))
2098                 addrbook_chkparse_folder_list(book, file);
2099 }
2100
2101 /**
2102  * Attempt to parse (DOM) tree from file.
2103  * \param book Address book.
2104  * \param file XML file handle.
2105  */
2106 static gboolean addrbook_chkread_tree(AddressBookFile *book, XMLFile *file)
2107 {
2108         GList *attr;
2109         gboolean retVal;
2110
2111         if (xml_get_dtd(file))
2112                 return FALSE;
2113
2114         if (xml_parse_next_tag(file))
2115                 return FALSE;
2116
2117         if (!xml_compare_tag(file, AB_ELTAG_ADDRESS_BOOK))
2118                 return FALSE;
2119
2120         attr = xml_get_current_tag_attr(file);
2121         /* addrbook_show_attribs( attr ); */
2122
2123         retVal = TRUE;
2124         for (;;) {
2125                 if (!file->level)
2126                         break;
2127                 /* Get item tag */
2128                 if (xml_parse_next_tag(file))
2129                         longjmp(book->jumper, 1);
2130
2131                 /* Get next tag (person, group or folder) */
2132                 if (xml_compare_tag(file, AB_ELTAG_PERSON))
2133                         addrbook_chkparse_person( book, file );
2134                 else if (xml_compare_tag(file, AB_ELTAG_GROUP))
2135                         addrbook_chkparse_group(book, file);
2136                 else if (xml_compare_tag(file, AB_ELTAG_FOLDER))
2137                         addrbook_chkparse_folder(book, file);
2138         }
2139         return retVal;
2140 }
2141
2142 /**
2143  * Test address book file by parsing contents.
2144  * \param  book     Address book.
2145  * \param  fileName Filename of XML file.
2146  * \return Status code <i>MGU_SUCCESS</i> if file appears to be valid format.
2147  */
2148 gint addrbook_test_read_file(AddressBookFile *book, gchar *fileName)
2149 {
2150         XMLFile *file = NULL;
2151         gchar *fileSpec = NULL;
2152
2153         g_return_val_if_fail(book != NULL, -1);
2154
2155         fileSpec = g_strconcat(book->path, G_DIR_SEPARATOR_S, fileName, NULL);
2156         book->retVal = MGU_OPEN_FILE;
2157         file = xml_open_file(fileSpec);
2158         g_free(fileSpec);
2159         if (file) {
2160                 book->retVal = MGU_BAD_FORMAT;
2161                 if (setjmp(book->jumper)) {
2162                         /* g_print( "Caught Ya!!!\n" ); */
2163                         xml_close_file(file);
2164                         return book->retVal;
2165                 }
2166                 if (addrbook_chkread_tree(book, file))
2167                         book->retVal = MGU_SUCCESS;
2168
2169                 xml_close_file( file );
2170         }
2171         return book->retVal;
2172 }
2173
2174 /**
2175  * Return link list of all persons in address book.  Note that the list
2176  * contains references to items. Do <b>*NOT*</b> attempt to use the
2177  * <code>addrbook_free_xxx()</code> functions... this will destroy the
2178  * addressbook data!
2179  * \param  book     Address book.
2180  * \return List of persons, or NULL if none.
2181  */
2182 GList *addrbook_get_all_persons(AddressBookFile *book)
2183 {
2184         g_return_val_if_fail(book != NULL, NULL);
2185         return addrcache_get_all_persons(book->addressCache);
2186 }
2187
2188 GList *addrbook_get_all_groups(AddressBookFile *book)
2189 {
2190         g_return_val_if_fail(book != NULL, NULL);
2191         return addrcache_get_all_groups(book->addressCache);
2192 }
2193
2194 /**
2195  * Add person and address data to address book.
2196  * \param  book    Address book.
2197  * \param  folder  Folder where to add person, or NULL for root folder.
2198  * \param  name    Common name.
2199  * \param  address EMail address.
2200  * \param  remarks Remarks.
2201  * \return Person added. Do not <b>*NOT*</b> to use the
2202  *         <code>addrbook_free_xxx()</code> functions... this will destroy
2203  *         the address book data.
2204  */
2205 ItemPerson *addrbook_add_contact(AddressBookFile *book, ItemFolder *folder,
2206                                  const gchar *name,const gchar *address,
2207                                  const gchar *remarks)
2208 {
2209         ItemPerson *person;
2210
2211         g_return_val_if_fail(book != NULL, NULL);
2212         person = addrcache_add_contact(
2213                         book->addressCache, folder, name, address, remarks );
2214         return person;
2215 }
2216
2217 /**
2218  * Return file name for next address book file.
2219  * \param  book Address book.
2220  * \return File name, or <i>NULL</i> if could not create. This should be
2221  *         <code>g_free()</code> when done.
2222  */
2223 gchar *addrbook_guess_next_file(AddressBookFile *book)
2224 {
2225         gchar *newFile = NULL;
2226         GList *fileList = NULL;
2227         gint fileNum = 1;
2228         fileList = addrbook_get_bookfile_list(book);
2229         if (fileList)
2230                 fileNum = 1 + book->maxValue;
2231
2232         newFile = addrbook_gen_new_file_name(fileNum);
2233         g_list_free(fileList);
2234         fileList = NULL;
2235         return newFile;
2236 }
2237
2238 /*
2239 * End of Source.
2240 */
2241
2242