gfgit/claws-mail
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
claws-mail/src/addrbook.c
Match Grun eb033d1c8b Dynamic LDAP queries
2003-03-17 06:49:25 +00:00

2032 lines
55 KiB
C
Raw Blame History

/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
* Copyright (C) 2001-2002 Match Grun and the Sylpheed-Claws team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/* General functions for accessing address book files */
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <sys/stat.h>
#include <math.h>
#include <setjmp.h>
#include "xml.h"
#include "mgutils.h"
#include "addritem.h"
#include "addrcache.h"
#include "addrbook.h"
#include "adbookbase.h"
#ifndef DEV_STANDALONE
#include "prefs_gtk.h"
#include "codeconv.h"
#endif
#define ADDRBOOK_MAX_SEARCH_COUNT 1000
#define ADDRBOOK_PREFIX "addrbook-"
#define ADDRBOOK_SUFFIX ".xml"
#define FILE_NUMDIGITS 6
#define ID_TIME_OFFSET 998000000
/* Create new address book */
AddressBookFile *addrbook_create_book()
{
AddressBookFile *book;
book = g_new0(AddressBookFile, 1);
book->type = ADBOOKTYPE_BOOK;
book->addressCache = addrcache_create();
book->retVal = MGU_SUCCESS;
book->path = NULL;
book->fileName = NULL;
book->maxValue = 0;
book->tempList = NULL;
book->tempHash = NULL;
book->addressCache->modified = TRUE;
/* We want to use an address completion index */
addrcache_use_index( book->addressCache, TRUE );
return book;
}
/* Specify name to be used */
void addrbook_set_name(AddressBookFile *book, const gchar *value)
{
g_return_if_fail(book != NULL);
addrcache_set_name(book->addressCache, value);
}
gchar *addrbook_get_name(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, NULL);
return addrcache_get_name(book->addressCache);
}
void addrbook_set_path(AddressBookFile *book, const gchar *value)
{
g_return_if_fail(book != NULL);
book->path = mgu_replace_string(book->path, value);
addrcache_set_dirty(book->addressCache, TRUE);
}
void addrbook_set_file(AddressBookFile *book, const gchar *value)
{
g_return_if_fail(book != NULL);
book->fileName = mgu_replace_string(book->fileName, value);
addrcache_set_dirty(book->addressCache, TRUE);
}
gboolean addrbook_get_modified(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, FALSE);
return book->addressCache->modified;
}
void addrbook_set_modified(AddressBookFile *book, const gboolean value)
{
g_return_if_fail(book != NULL);
book->addressCache->modified = value;
}
gboolean addrbook_get_accessed(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, FALSE);
return book->addressCache->accessFlag;
}
void addrbook_set_accessed(AddressBookFile *book, const gboolean value)
{
g_return_if_fail(book != NULL);
book->addressCache->accessFlag = value;
}
gboolean addrbook_get_read_flag(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, FALSE);
return book->addressCache->dataRead;
}
void addrbook_set_read_flag(AddressBookFile *book, const gboolean value)
{
g_return_if_fail(book != NULL);
book->addressCache->dataRead = value;
}
gint addrbook_get_status(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, -1);
return book->retVal;
}
ItemFolder *addrbook_get_root_folder(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, NULL);
return addrcache_get_root_folder(book->addressCache);
}
GList *addrbook_get_list_folder(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, NULL);
return addrcache_get_list_folder(book->addressCache);
}
GList *addrbook_get_list_person(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, NULL);
return addrcache_get_list_person(book->addressCache);
}
gboolean addrbook_get_dirty(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, FALSE);
return addrcache_get_dirty(book->addressCache);
}
void addrbook_set_dirty(AddressBookFile *book, const gboolean value)
{
g_return_if_fail(book != NULL);
addrcache_set_dirty(book->addressCache, value);
}
/* Empty address book */
void addrbook_empty_book(AddressBookFile *book)
{
g_return_if_fail(book != NULL);
/* Free up internal objects */
addrcache_clear(book->addressCache);
addrcache_set_dirty(book->addressCache, FALSE);
g_list_free(book->tempList);
/* Reset to initial state */
book->tempList = NULL;
book->tempHash = NULL;
book->addressCache->dataRead = FALSE;
book->addressCache->modified = FALSE;
book->addressCache->accessFlag = FALSE;
book->retVal = MGU_SUCCESS;
}
/* Free address book */
void addrbook_free_book(AddressBookFile *book)
{
g_return_if_fail(book != NULL);
/* Clear cache */
addrcache_free(book->addressCache);
/* Free up internal objects */
g_free(book->path);
g_free(book->fileName);
g_list_free(book->tempList);
book->path = NULL;
book->fileName = NULL;
book->maxValue = 0;
book->tempList = NULL;
book->tempHash = NULL;
book->type = ADBOOKTYPE_NONE;
book->addressCache = NULL;
book->retVal = MGU_SUCCESS;
g_free(book);
}
/* Print list of items */
void addrbook_print_item_list(GList *list, FILE *stream)
{
GList *node = list;
while(node) {
AddrItemObject *obj = node->data;
if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON)
addritem_print_item_person((ItemPerson *) obj, stream);
else if (ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP)
addritem_print_item_group((ItemGroup *) obj, stream);
else if (ADDRITEM_TYPE(obj) == ITEMTYPE_FOLDER)
addritem_print_item_folder((ItemFolder *) obj, stream);
node = g_list_next(node);
}
fprintf(stream, "\t---\n");
}
/* Print address book */
void addrbook_print_book(AddressBookFile *book, FILE *stream)
{
g_return_if_fail(book != NULL);
fprintf(stream, "AddressBook:\n");
fprintf(stream, "\tpath : '%s'\n", book->path);
fprintf(stream, "\tfile : '%s'\n", book->fileName);
fprintf(stream, "\tstatus : %d\n", book->retVal );
addrcache_print(book->addressCache, stream);
}
/* Dump entire address book traversing folders */
void addrbook_dump_book(AddressBookFile *book, FILE *stream)
{
ItemFolder *folder;
g_return_if_fail(book != NULL);
addrbook_print_book(book, stream);
folder = book->addressCache->rootFolder;
addritem_print_item_folder(folder, stream);
}
/* Remove group from address book.
param: group Group to remove.
return: Group, or NULL if not found.
Note that object should still be freed */
ItemGroup *addrbook_remove_group(AddressBookFile *book, ItemGroup *group)
{
g_return_val_if_fail(book != NULL, NULL);
return addrcache_remove_group(book->addressCache, group);
}
/* Remove specified person from address book.
param: person Person to remove.
return: Person, or NULL if not found.
Note that object should still be freed */
ItemPerson *addrbook_remove_person(AddressBookFile *book, ItemPerson *person)
{
g_return_val_if_fail(book != NULL, NULL);
return addrcache_remove_person(book->addressCache, person);
}
/* Remove email address in address book for specified person.
param: person Person.
email EMail to remove.
return: EMail object, or NULL if not found.
Note that object should still be freed */
ItemEMail *addrbook_person_remove_email(AddressBookFile *book,
ItemPerson *person, ItemEMail *email)
{
g_return_val_if_fail(book != NULL, NULL);
return addrcache_person_remove_email(book->addressCache, person, email);
}
/* **********************************************************************
* Read/Write XML data file...
* ===========================
* Notes:
* 1) The address book is structured as follows:
*
* address-book
* person
* address-list
* address
* attribute-list
* attribute
* group
* member-list
* member
* folder
* item-list
* item
*
* 2) This sequence of elements was chosen so that the most important
* elements (person and their email addresses) appear first.
*
* 3) Groups then appear. When groups are loaded, person's email
* addresses have already been loaded and can be found.
*
* 4) Finally folders are loaded. Any forward and backward references
* to folders, groups and persons in the folders are resolved after
* loading.
*
* ***********************************************************************
*/
/* Element tag names */
#define AB_ELTAG_ADDRESS "address"
#define AB_ELTAG_ATTRIBUTE "attribute"
#define AB_ELTAG_ATTRIBUTE_LIST "attribute-list"
#define AB_ELTAG_ADDRESS_LIST "address-list"
#define AB_ELTAG_MEMBER "member"
#define AB_ELTAG_MEMBER_LIST "member-list"
#define AB_ELTAG_ITEM "item"
#define AB_ELTAG_ITEM_LIST "item-list"
#define AB_ELTAG_ADDRESS_BOOK "address-book"
#define AB_ELTAG_PERSON "person"
#define AB_ELTAG_GROUP "group"
#define AB_ELTAG_FOLDER "folder"
/* Attribute tag names */
#define AB_ATTAG_TYPE "type"
#define AB_ATTAG_UID "uid"
#define AB_ATTAG_NAME "name"
#define AB_ATTAG_REMARKS "remarks"
#define AB_ATTAG_FIRST_NAME "first-name"
#define AB_ATTAG_LAST_NAME "last-name"
#define AB_ATTAG_NICK_NAME "nick-name"
#define AB_ATTAG_COMMON_NAME "cn"
#define AB_ATTAG_ALIAS "alias"
#define AB_ATTAG_EMAIL "email"
#define AB_ATTAG_EID "eid"
#define AB_ATTAG_PID "pid"
/* Attribute values */
#define AB_ATTAG_VAL_PERSON "person"
#define AB_ATTAG_VAL_GROUP "group"
#define AB_ATTAG_VAL_FOLDER "folder"
/* Parse address item for person */
static void addrbook_parse_address(AddressBookFile *book, XMLFile *file,
ItemPerson *person)
{
GList *attr;
gchar *name, *value;
ItemEMail *email = NULL;
attr = xml_get_current_tag_attr(file);
while (attr) {
name = ((XMLAttr *)attr->data)->name;
value = ((XMLAttr *)attr->data)->value;
if (!email)
email = addritem_create_item_email();
if (strcmp(name, AB_ATTAG_UID) == 0)
ADDRITEM_ID(email) = g_strdup(value);
else if (strcmp(name, AB_ATTAG_ALIAS) == 0)
ADDRITEM_NAME(email) = g_strdup(value);
else if (strcmp(name, AB_ATTAG_EMAIL) == 0)
email->address = g_strdup(value);
else if (strcmp(name, AB_ATTAG_REMARKS) == 0)
email->remarks = g_strdup(value);
attr = g_list_next(attr);
}
if (email) {
if (person) {
addrcache_person_add_email(book->addressCache, person,
email);
}
else {
addritem_free_item_email(email);
email = NULL;
}
}
}
/* Parse email address list */
static void addrbook_parse_addr_list(AddressBookFile *book, XMLFile *file,
ItemPerson *person)
{
GList *attr;
guint prev_level;
for (;;) {
prev_level = file->level;
if (xml_parse_next_tag(file)) {
longjmp(book->jumper, 1);
}
if (file->level < prev_level) return;
if (xml_compare_tag(file, AB_ELTAG_ADDRESS)) {
attr = xml_get_current_tag_attr(file);
addrbook_parse_address(book, file, person);
addrbook_parse_addr_list(book, file, person);
}
}
}
/* Parse attibute for person */
static void addrbook_parse_attribute(XMLFile *file, ItemPerson *person)
{
GList *attr;
gchar *name, *value;
gchar *element;
UserAttribute *uAttr = NULL;
attr = xml_get_current_tag_attr(file);
while (attr) {
name = ((XMLAttr *)attr->data)->name;
value = ((XMLAttr *)attr->data)->value;
if (!uAttr) uAttr = addritem_create_attribute();
if (strcmp(name, AB_ATTAG_UID) == 0)
addritem_attrib_set_id(uAttr, value);
else if (strcmp(name, AB_ATTAG_NAME) == 0)
addritem_attrib_set_name(uAttr, value);
attr = g_list_next(attr);
}
element = xml_get_element(file);
addritem_attrib_set_value(uAttr, element);
if (uAttr) {
if (person) {
addritem_person_add_attribute(person, uAttr);
}
else {
addritem_free_attribute(uAttr);
uAttr = NULL;
}
}
}
/* Parse attribute list */
static void addrbook_parse_attr_list(AddressBookFile *book, XMLFile *file,
ItemPerson *person)
{
GList *attr;
guint prev_level;
for (;;) {
prev_level = file->level;
if (xml_parse_next_tag(file)) {
longjmp( book->jumper, 1 );
}
if (file->level < prev_level) return;
if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE)) {
attr = xml_get_current_tag_attr(file);
addrbook_parse_attribute(file, person);
addrbook_parse_attr_list(book, file, person);
}
}
}
/* Parse person */
static void addrbook_parse_person(AddressBookFile *book, XMLFile *file)
{
GList *attr;
gchar *name, *value;
ItemPerson *person = NULL;
attr = xml_get_current_tag_attr(file);
while (attr) {
name = ((XMLAttr *)attr->data)->name;
value = ((XMLAttr *)attr->data)->value;
if (!person)
person = addritem_create_item_person();
if (strcmp(name, AB_ATTAG_UID) == 0)
ADDRITEM_ID(person) = g_strdup(value);
else if (strcmp(name, AB_ATTAG_FIRST_NAME) == 0)
person->firstName = g_strdup(value);
else if (strcmp(name, AB_ATTAG_LAST_NAME) == 0)
person->lastName = g_strdup(value);
else if (strcmp(name, AB_ATTAG_NICK_NAME) == 0)
person->nickName = g_strdup(value);
else if (strcmp(name, AB_ATTAG_COMMON_NAME) == 0)
ADDRITEM_NAME(person) = g_strdup(value);
attr = g_list_next(attr);
}
if (xml_parse_next_tag(file)) { /* Consume closing tag */
longjmp(book->jumper, 1);
}
if (xml_compare_tag(file, AB_ELTAG_ADDRESS_LIST)) {
addrbook_parse_addr_list(book, file, person);
if (person) {
addrcache_hash_add_person(book->addressCache, person);
}
}
if (xml_parse_next_tag(file)) { /* Consume closing tag */
longjmp(book->jumper, 1);
}
if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE_LIST)) {
addrbook_parse_attr_list(book, file, person);
}
}
/* Parse group member */
static void addrbook_parse_member(AddressBookFile *book, XMLFile *file,
ItemGroup *group)
{
GList *attr;
gchar *name, *value;
gchar *pid = NULL, *eid = NULL;
ItemEMail *email = NULL;
attr = xml_get_current_tag_attr(file);
while (attr) {
name = ((XMLAttr *)attr->data)->name;
value = ((XMLAttr *)attr->data)->value;
if (strcmp(name, AB_ATTAG_PID) == 0)
pid = g_strdup(value);
else if (strcmp(name, AB_ATTAG_EID) == 0)
eid = g_strdup(value);
attr = g_list_next(attr);
}
/* email = addrcache_get_email( book->addressCache, pid, eid ); */
email = addrcache_get_email(book->addressCache, eid);
if (email) {
if (group) {
addrcache_group_add_email(book->addressCache, group,
email);
}
else {
addritem_free_item_email(email);
email = NULL;
}
}
}
/* Parse group member list */
static void addrbook_parse_member_list(AddressBookFile *book, XMLFile *file,
ItemGroup *group)
{
GList *attr;
guint prev_level;
for (;;) {
prev_level = file->level;
if (xml_parse_next_tag(file)) {
longjmp(book->jumper, 1);
}
if (file->level < prev_level)
return;
if (xml_compare_tag(file, AB_ELTAG_MEMBER)) {
attr = xml_get_current_tag_attr(file);
addrbook_parse_member(book, file, group);
addrbook_parse_member_list(book, file, group);
}
else {
attr = xml_get_current_tag_attr(file);
}
}
}
/* Parse group */
static void addrbook_parse_group(AddressBookFile *book, XMLFile *file)
{
GList *attr;
gchar *name, *value;
ItemGroup *group = NULL;
attr = xml_get_current_tag_attr(file);
while (attr) {
name = ((XMLAttr *)attr->data)->name;
value = ((XMLAttr *)attr->data)->value;
if (!group)
group = addritem_create_item_group();
if (strcmp(name, AB_ATTAG_UID) == 0)
ADDRITEM_ID(group) = g_strdup(value);
else if (strcmp(name, AB_ATTAG_NAME) == 0)
ADDRITEM_NAME(group) = g_strdup(value);
else if (strcmp(name, AB_ATTAG_REMARKS) == 0)
group->remarks = g_strdup(value);
attr = g_list_next(attr);
}
if (xml_parse_next_tag(file)) { /* Consume closing tag */
longjmp(book->jumper, 1);
}
if (xml_compare_tag(file, AB_ELTAG_MEMBER_LIST)) {
if (group) {
addrcache_hash_add_group(book->addressCache, group);
}
addrbook_parse_member_list(book, file, group);
}
}
/* Parse folder item */
static void addrbook_parse_folder_item(AddressBookFile *book, XMLFile *file,
ItemFolder *folder)
{
GList *attr;
gchar *name, *value;
gchar *uid = NULL;
attr = xml_get_current_tag_attr(file);
while (attr) {
name = ((XMLAttr *)attr->data)->name;
value = ((XMLAttr *)attr->data)->value;
if (strcmp(name, AB_ATTAG_UID) == 0) {
uid = g_strdup(value);
}
attr = g_list_next(attr);
}
if (folder) {
if (uid) {
folder->listItems = g_list_append(folder->listItems, uid);
}
}
}
/* Parse folder item list */
static void addrbook_parse_folder_list(AddressBookFile *book, XMLFile *file,
ItemFolder *folder)
{
GList *attr;
guint prev_level;
for (;;) {
prev_level = file->level;
if (xml_parse_next_tag(file)) {
longjmp(book->jumper, 1);
}
if (file->level < prev_level)
return;
if (xml_compare_tag(file, AB_ELTAG_ITEM)) {
attr = xml_get_current_tag_attr(file);
addrbook_parse_folder_item(book, file, folder);
addrbook_parse_folder_list(book, file, folder);
}
else {
attr = xml_get_current_tag_attr(file);
}
}
}
/* Parse folder */
static void addrbook_parse_folder(AddressBookFile *book, XMLFile *file)
{
GList *attr;
gchar *name, *value;
ItemFolder *folder = NULL;
attr = xml_get_current_tag_attr(file);
while (attr) {
name = ((XMLAttr *)attr->data)->name;
value = ((XMLAttr *)attr->data)->value;
if (!folder)
folder = addritem_create_item_folder();
if (strcmp(name, AB_ATTAG_UID) == 0)
ADDRITEM_ID(folder) = g_strdup(value);
else if (strcmp(name, AB_ATTAG_NAME) == 0)
ADDRITEM_NAME(folder) = g_strdup(value);
else if (strcmp(name, AB_ATTAG_REMARKS) == 0)
folder->remarks = g_strdup(value);
attr = g_list_next(attr);
}
if (xml_parse_next_tag(file)) { /* Consume closing tag */
longjmp(book->jumper, 1);
}
if (xml_compare_tag(file, AB_ELTAG_ITEM_LIST)) {
if (folder) {
if (addrcache_hash_add_folder(book->addressCache,
folder)) {
book->tempList = g_list_append(book->tempList,
folder);
/* We will resolve folder later */
ADDRITEM_PARENT(folder) = NULL;
}
}
addrbook_parse_folder_list(book, file, folder);
}
}
/* Parse address book.
Return: TRUE if data read successfully, FALSE if error reading data */
static gboolean addrbook_read_tree(AddressBookFile *book, XMLFile *file)
{
gboolean retVal;
GList *attr;
gchar *name, *value;
book->retVal = MGU_BAD_FORMAT;
if (xml_get_dtd(file))
return FALSE;
if (xml_parse_next_tag(file))
longjmp(book->jumper, 1);
if (!xml_compare_tag(file, AB_ELTAG_ADDRESS_BOOK))
return FALSE;
attr = xml_get_current_tag_attr(file);
while (attr) {
name = ((XMLAttr *)attr->data)->name;
value = ((XMLAttr *)attr->data)->value;
if (strcmp( name, AB_ATTAG_NAME) == 0)
addrbook_set_name( book, value );
attr = g_list_next( attr );
}
retVal = TRUE;
for (;;) {
if (!file->level)
break;
/* Get next item tag (person, group or folder) */
if (xml_parse_next_tag(file))
longjmp( book->jumper, 1 );
if (xml_compare_tag(file, AB_ELTAG_PERSON))
addrbook_parse_person(book, file);
else if (xml_compare_tag(file, AB_ELTAG_GROUP))
addrbook_parse_group(book, file);
else if (xml_compare_tag(file, AB_ELTAG_FOLDER))
addrbook_parse_folder(book, file);
}
if (retVal) book->retVal = MGU_SUCCESS;
return retVal;
}
/* Resolve folder items visitor function */
static void addrbook_res_items_vis(gpointer key, gpointer value, gpointer data)
{
AddressBookFile *book = data;
AddrItemObject *obj = (AddrItemObject *) value;
ItemFolder *rootFolder = book->addressCache->rootFolder;
if (obj->parent == NULL) {
if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON) {
rootFolder->listPerson = g_list_append(rootFolder->listPerson,
obj);
ADDRITEM_PARENT(obj) = ADDRITEM_OBJECT(rootFolder);
}
else if (ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP) {
rootFolder->listGroup = g_list_append(rootFolder->listGroup,
obj);
ADDRITEM_PARENT(obj) = ADDRITEM_OBJECT(rootFolder);
}
}
}
/* Resolve folder items. Lists of UID's are replaced with pointers to
data items */
static void addrbook_resolve_folder_items(AddressBookFile *book)
{
GList *nodeFolder = NULL;
GList *listRemove = NULL;
GList *node = NULL;
ItemFolder *rootFolder = book->addressCache->rootFolder;
nodeFolder = book->tempList;
while (nodeFolder) {
ItemFolder *folder = nodeFolder->data;
listRemove = NULL;
node = folder->listItems;
while (node) {
gchar *uid = node->data;
AddrItemObject *aio = addrcache_get_object(book->addressCache,
uid);
if (aio) {
if (aio->type == ITEMTYPE_FOLDER) {
ItemFolder *item = (ItemFolder *) aio;
folder->listFolder = g_list_append(folder->listFolder, item);
ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
addrcache_hash_add_folder(book->addressCache, folder);
}
else if (aio->type == ITEMTYPE_PERSON) {
ItemPerson *item = (ItemPerson *) aio;
folder->listPerson = g_list_append(folder->listPerson, item);
ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
}
else if (aio->type == ITEMTYPE_GROUP) {
ItemGroup *item = (ItemGroup *) aio;
folder->listGroup = g_list_append(folder->listGroup, item);
ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
}
/* Replace data with pointer to item */
g_free(uid);
node->data = aio;
}
else { /* Not found, append to remove list. */
listRemove = g_list_append(listRemove, uid);
}
node = g_list_next(node);
}
rootFolder->listFolder = g_list_append(rootFolder->listFolder,
folder);
/* Process remove list */
node = listRemove;
while (node) {
gchar *uid = node->data;
folder->listItems = g_list_remove(folder->listItems,
uid);
g_free(uid);
node = g_list_next(node);
}
g_list_free(listRemove);
nodeFolder = g_list_next(nodeFolder);
}
/* Remove folders with parents. */
listRemove = NULL;
node = rootFolder->listFolder;
while (node) {
ItemFolder *folder = (ItemFolder *) node->data;
if (ADDRITEM_PARENT(folder))
/* Remove folders with parents */
listRemove = g_list_append(listRemove, folder);
else /* Add to root folder */
ADDRITEM_PARENT(folder) = ADDRITEM_OBJECT(book->addressCache->rootFolder);
node = g_list_next( node );
}
/* Process remove list */
node = listRemove;
while (node) {
rootFolder->listFolder = g_list_remove(rootFolder->listFolder,
node->data);
node = g_list_next(node);
}
g_list_free(listRemove);
/* Move all unparented persons and groups into root folder */
g_hash_table_foreach(book->addressCache->itemHash,
addrbook_res_items_vis, book);
/* Free up some more */
nodeFolder = book->tempList;
while (nodeFolder) {
ItemFolder *folder = nodeFolder->data;
g_list_free(folder->listItems);
folder->listItems = NULL;
nodeFolder = g_list_next(nodeFolder);
}
g_list_free(book->tempList);
book->tempList = NULL;
}
/* Read address book file */
gint addrbook_read_data(AddressBookFile *book)
{
XMLFile *file = NULL;
gchar *fileSpec = NULL;
g_return_val_if_fail(book != NULL, -1);
/*
printf( "...addrbook_read_data :%s:\t:%s:\n", book->fileName,
addrcache_get_name( book->addressCache ) );
*/
fileSpec = g_strconcat(book->path, G_DIR_SEPARATOR_S,
book->fileName, NULL);
book->retVal = MGU_OPEN_FILE;
addrcache_clear(book->addressCache);
book->addressCache->modified = FALSE;
book->addressCache->accessFlag = FALSE;
file = xml_open_file(fileSpec);
g_free(fileSpec);
if (file) {
book->tempList = NULL;
/* Trap for parsing errors. */
if (setjmp( book->jumper)) {
xml_close_file(file);
return book->retVal;
}
addrbook_read_tree(book, file);
xml_close_file(file);
/* Resolve folder items */
addrbook_resolve_folder_items(book);
book->tempList = NULL;
book->addressCache->modified = FALSE;
book->addressCache->dataRead = TRUE;
addrcache_set_dirty(book->addressCache, FALSE);
/* Build address completion index */
addrcache_build_index( book->addressCache );
}
return book->retVal;
}
static void addrbook_write_elem_s(FILE *fp, gint lvl, gchar *name)
{
gint i;
for (i = 0; i < lvl; i++)
fputs(" ", fp);
fputs("<", fp);
fputs(name, fp);
}
static void addrbook_write_elem_e(FILE *fp, gint lvl, gchar *name)
{
gint i;
for(i = 0; i < lvl; i++)
fputs(" ", fp);
fputs("</", fp);
fputs(name, fp);
fputs(">\n", fp);
}
static void addrbook_write_attr(FILE *fp, gchar *name, gchar *value)
{
fputs(" ", fp);
fputs(name, fp);
fputs("=\"", fp);
xml_file_put_escape_str(fp, value);
fputs("\"", fp);
}
/* Write file hash table visitor function */
static void addrbook_write_item_person_vis(gpointer key, gpointer value,
gpointer data)
{
AddrItemObject *obj = (AddrItemObject *) value;
FILE *fp = (FILE *) data;
GList *node;
if (!obj)
return;
if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON) {
ItemPerson *person = (ItemPerson *) value;
if (person) {
addrbook_write_elem_s(fp, 1, AB_ELTAG_PERSON);
addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(person));
addrbook_write_attr(fp, AB_ATTAG_FIRST_NAME, person->firstName);
addrbook_write_attr(fp, AB_ATTAG_LAST_NAME, person->lastName);
addrbook_write_attr(fp, AB_ATTAG_NICK_NAME, person->nickName);
addrbook_write_attr(fp, AB_ATTAG_COMMON_NAME, ADDRITEM_NAME(person));
fputs(" >\n", fp);
/* Output email addresses */
addrbook_write_elem_s(fp, 2, AB_ELTAG_ADDRESS_LIST);
fputs(">\n", fp);
node = person->listEMail;
while (node) {
ItemEMail *email = node->data;
addrbook_write_elem_s(fp, 3, AB_ELTAG_ADDRESS);
addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(email));
addrbook_write_attr(fp, AB_ATTAG_ALIAS, ADDRITEM_NAME(email));
addrbook_write_attr(fp, AB_ATTAG_EMAIL, email->address);
addrbook_write_attr(fp, AB_ATTAG_REMARKS, email->remarks);
fputs(" />\n", fp);
node = g_list_next(node);
}
addrbook_write_elem_e(fp, 2, AB_ELTAG_ADDRESS_LIST);
/* Output user attributes */
addrbook_write_elem_s(fp, 2, AB_ELTAG_ATTRIBUTE_LIST);
fputs(">\n", fp);
node = person->listAttrib;
while (node) {
UserAttribute *attrib = node->data;
addrbook_write_elem_s(fp, 3, AB_ELTAG_ATTRIBUTE);
addrbook_write_attr(fp, AB_ATTAG_UID, attrib->uid);
addrbook_write_attr(fp, AB_ATTAG_NAME, attrib->name);
fputs(" >", fp);
xml_file_put_escape_str(fp, attrib->value);
addrbook_write_elem_e(fp, 0, AB_ELTAG_ATTRIBUTE);
node = g_list_next(node);
}
addrbook_write_elem_e(fp, 2, AB_ELTAG_ATTRIBUTE_LIST);
addrbook_write_elem_e(fp, 1, AB_ELTAG_PERSON);
}
}
}
/* Write file hash table visitor function */
static void addrbook_write_item_group_vis(gpointer key, gpointer value,
gpointer data)
{
AddrItemObject *obj = (AddrItemObject *) value;
FILE *fp = (FILE *) data;
GList *node;
if (!obj)
return;
if (ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP) {
ItemGroup *group = (ItemGroup *) value;
if (group) {
addrbook_write_elem_s(fp, 1, AB_ELTAG_GROUP);
addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(group));
addrbook_write_attr(fp, AB_ATTAG_NAME, ADDRITEM_NAME(group));
addrbook_write_attr(fp, AB_ATTAG_REMARKS, group->remarks);
fputs(" >\n", fp);
/* Output email address links */
addrbook_write_elem_s(fp, 2, AB_ELTAG_MEMBER_LIST);
fputs(">\n", fp);
node = group->listEMail;
while (node) {
ItemEMail *email = node->data;
ItemPerson *person = (ItemPerson *) ADDRITEM_PARENT(email);
addrbook_write_elem_s(fp, 3, AB_ELTAG_MEMBER);
addrbook_write_attr(fp, AB_ATTAG_PID, ADDRITEM_ID(person));
addrbook_write_attr(fp, AB_ATTAG_EID, ADDRITEM_ID(email));
fputs(" />\n", fp);
node = g_list_next(node);
}
addrbook_write_elem_e(fp, 2, AB_ELTAG_MEMBER_LIST);
addrbook_write_elem_e(fp, 1, AB_ELTAG_GROUP);
}
}
}
/* Write file hash table visitor function */
static void addrbook_write_item_folder_vis(gpointer key, gpointer value,
gpointer data)
{
AddrItemObject *obj = (AddrItemObject *) value;
FILE *fp = (FILE *) data;
GList *node;
if (!obj)
return;
if (ADDRITEM_TYPE(obj) == ITEMTYPE_FOLDER) {
ItemFolder *folder = (ItemFolder *) value;
if (folder) {
addrbook_write_elem_s(fp, 1, AB_ELTAG_FOLDER);
addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(folder));
addrbook_write_attr(fp, AB_ATTAG_NAME, ADDRITEM_NAME(folder));
addrbook_write_attr(fp, AB_ATTAG_REMARKS, folder->remarks);
fputs(" >\n", fp);
addrbook_write_elem_s(fp, 2, AB_ELTAG_ITEM_LIST);
fputs(">\n", fp);
/* Output persons */
node = folder->listPerson;
while (node) {
ItemPerson *item = node->data;
addrbook_write_elem_s(fp, 3, AB_ELTAG_ITEM);
addrbook_write_attr(fp, AB_ATTAG_TYPE, AB_ATTAG_VAL_PERSON);
addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(item));
fputs(" />\n", fp);
node = g_list_next(node);
}
/* Output groups */
node = folder->listGroup;
while (node) {
ItemGroup *item = node->data;
addrbook_write_elem_s(fp, 3, AB_ELTAG_ITEM);
addrbook_write_attr(fp, AB_ATTAG_TYPE, AB_ATTAG_VAL_GROUP);
addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(item));
fputs(" />\n", fp);
node = g_list_next(node);
}
/* Output folders */
node = folder->listFolder;
while (node) {
ItemFolder *item = node->data;
addrbook_write_elem_s(fp, 3, AB_ELTAG_ITEM);
addrbook_write_attr(fp, AB_ATTAG_TYPE, AB_ATTAG_VAL_FOLDER);
addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(item));
fputs(" />\n", fp);
node = g_list_next(node);
}
addrbook_write_elem_e(fp, 2, AB_ELTAG_ITEM_LIST);
addrbook_write_elem_e(fp, 1, AB_ELTAG_FOLDER);
}
}
}
/* Output address book data to specified file.
return: Status code */
gint addrbook_write_to(AddressBookFile *book, gchar *newFile)
{
FILE *fp;
gchar *fileSpec;
#ifndef DEV_STANDALONE
PrefFile *pfile;
#endif
g_return_val_if_fail(book != NULL, -1);
g_return_val_if_fail(newFile != NULL, -1);
fileSpec = g_strconcat(book->path, G_DIR_SEPARATOR_S, newFile, NULL);
book->retVal = MGU_OPEN_FILE;
#ifdef DEV_STANDALONE
fp = fopen(fileSpec, "wb");
g_free(fileSpec);
if (fp) {
fputs("<?xml version=\"1.0\" ?>\n", fp);
#else
pfile = prefs_write_open(fileSpec);
g_free(fileSpec);
if (pfile) {
fp = pfile->fp;
fprintf(fp, "<?xml version=\"1.0\" encoding=\"%s\" ?>\n",
conv_get_current_charset_str());
#endif
addrbook_write_elem_s(fp, 0, AB_ELTAG_ADDRESS_BOOK);
addrbook_write_attr(fp, AB_ATTAG_NAME,
addrcache_get_name(book->addressCache));
fputs(" >\n", fp);
/* Output all persons */
g_hash_table_foreach(book->addressCache->itemHash,
addrbook_write_item_person_vis, fp);
/* Output all groups */
g_hash_table_foreach(book->addressCache->itemHash,
addrbook_write_item_group_vis, fp);
/* Output all folders */
g_hash_table_foreach(book->addressCache->itemHash,
addrbook_write_item_folder_vis, fp);
addrbook_write_elem_e(fp, 0, AB_ELTAG_ADDRESS_BOOK);
book->retVal = MGU_SUCCESS;
#ifdef DEV_STANDALONE
fclose(fp);
#else
if (prefs_file_close( pfile ) < 0)
book->retVal = MGU_ERROR_WRITE;
#endif
}
fileSpec = NULL;
return book->retVal;
}
/* Output address book data to original file.
return: Status code */
gint addrbook_save_data(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, -1);
book->retVal = MGU_NO_FILE;
if (book->fileName == NULL || *book->fileName == '\0')
return book->retVal;
if (book->path == NULL || *book->path == '\0')
return book->retVal;
addrbook_write_to(book, book->fileName);
if (book->retVal == MGU_SUCCESS)
addrcache_set_dirty(book->addressCache, FALSE);
return book->retVal;
}
/* **********************************************************************
Address book edit interface functions...
***********************************************************************
Move person's email item.
param: book Address book.
person Person.
itemMove Item to move.
itemTarget Target item before which to move item */
ItemEMail *addrbook_move_email_before(AddressBookFile *book, ItemPerson *person,
ItemEMail *itemMove, ItemEMail *itemTarget)
{
ItemEMail *email = NULL;
g_return_val_if_fail(book != NULL, NULL);
email = addritem_move_email_before(person, itemMove, itemTarget);
if (email)
addrcache_set_dirty(book->addressCache, TRUE);
return email;
}
/* Move person's email item.
param: book Address book.
person Person.
itemMove Item to move.
itemTarget Target item after which to move item */
ItemEMail *addrbook_move_email_after(AddressBookFile *book, ItemPerson *person,
ItemEMail *itemMove, ItemEMail *itemTarget)
{
ItemEMail *email = NULL;
g_return_val_if_fail(book != NULL, NULL);
email = addritem_move_email_after(person, itemMove, itemTarget);
if (email)
addrcache_set_dirty(book->addressCache, TRUE);
return email;
}
/* Hash table visitor function for deletion of hashtable entries */
static gboolean addrbook_free_simple_hash_vis(gpointer *key, gpointer *value,
gpointer *data)
{
g_free(key);
key = NULL;
value = NULL;
return TRUE;
}
/* Update address book email list for specified person.
Enter: book Address book.
person Person to update.
listEMail List of new email addresses.
Note: The existing email addresses are replaced with the new addresses. Any references
to old addresses in the groups are re-linked to the new addresses. All old addresses
linked to the person are removed */
void addrbook_update_address_list(AddressBookFile *book, ItemPerson *person,
GList *listEMail)
{
GList *node;
GList *listDelete;
GList *listGroup;
g_return_if_fail(book != NULL);
g_return_if_fail(person != NULL);
/* Get groups where person's existing email addresses are listed */
listGroup = addrcache_get_group_for_person(book->addressCache, person);
if (listGroup) {
GHashTable *hashEMail;
GHashTable *hashEMailAlias;
GList *nodeGrp;
/* Load hash table with new address entries */
hashEMail = g_hash_table_new(g_str_hash, g_str_equal);
hashEMailAlias = g_hash_table_new(g_str_hash, g_str_equal);
node = listEMail;
while (node) {
ItemEMail *email = node->data;
gchar *addr = g_strdup(email->address);
gchar *alias = email->obj.name ;
g_strdown(addr);
if (!g_hash_table_lookup(hashEMail, addr)) {
g_hash_table_insert(hashEMail, addr, email);
}
if (*alias != '\0' && ! g_hash_table_lookup(hashEMailAlias,
alias))
g_hash_table_insert(hashEMailAlias, alias, email);
node = g_list_next(node);
}
/* Re-parent new addresses to existing groups, where email address match. */
nodeGrp = listGroup;
while (nodeGrp) {
ItemGroup *group = (ItemGroup *) nodeGrp->data;
GList *groupEMail = group->listEMail;
GList *nodeGrpEM;
GList *listRemove = NULL;
/* Process each email item linked to group */
nodeGrpEM = groupEMail;
while (nodeGrpEM) {
ItemEMail *emailGrp = (ItemEMail *) nodeGrpEM->data;
if (ADDRITEM_PARENT(emailGrp) == ADDRITEM_OBJECT(person)) {
/* Found an email address for this person */
ItemEMail *emailNew = NULL;
gchar *addr = g_strdup(emailGrp->address);
gchar *alias = emailGrp->obj.name;
g_strdown(addr);
emailNew = (ItemEMail *)
g_hash_table_lookup(hashEMail, addr);
g_free( addr );
/* If no match by e-mail, try to match by e-mail alias */
if (!emailNew && *alias != '\0') {
emailNew = (ItemEMail *)
g_hash_table_lookup(hashEMailAlias, alias);
}
if (emailNew)
/* Point to this entry */
nodeGrpEM->data = emailNew;
else if (g_hash_table_size(hashEMail)==1)
/* If the person has just one e-mail address, then
change e-mail address in group list */
nodeGrpEM->data = listEMail->data;
else
/* Mark for removal */
listRemove = g_list_append(listRemove, emailGrp);
}
/* Move on to next email link */
nodeGrpEM = g_list_next(nodeGrpEM);
}
/* Process all removed links in current group */
nodeGrpEM = listRemove;
while (nodeGrpEM) {
ItemEMail *emailGrp = nodeGrpEM->data;
groupEMail = g_list_remove(groupEMail, emailGrp);
nodeGrpEM = g_list_next(nodeGrpEM);
}
g_list_free(listRemove);
/* Move on to next group */
nodeGrp = g_list_next(nodeGrp);
}
/* Clear hash table */
g_hash_table_foreach_remove(hashEMail, (GHRFunc)
addrbook_free_simple_hash_vis, NULL);
g_hash_table_destroy(hashEMail);
hashEMail = NULL;
g_hash_table_destroy(hashEMailAlias);
hashEMailAlias = NULL;
g_list_free(listGroup);
listGroup = NULL;
}
/* Remove old addresses from person and cache */
listDelete = NULL;
node = person->listEMail;
while (node) {
ItemEMail *email = node->data;
if (addrcache_person_remove_email(book->addressCache, person, email))
addrcache_remove_email(book->addressCache, email);
listDelete = g_list_append(listDelete, email);
node = person->listEMail;
}
/* Add new address entries */
node = listEMail;
while (node) {
ItemEMail *email = node->data;
if (ADDRITEM_ID(email) == NULL)
/* Allocate an ID for new address */
addrcache_id_email(book->addressCache, email);
addrcache_person_add_email( book->addressCache, person, email );
node = g_list_next( node );
}
addrcache_set_dirty(book->addressCache, TRUE);
/* Free up memory */
g_list_free(listEMail);
listEMail = NULL;
node = listDelete;
while (node) {
ItemEMail *email = node->data;
addritem_free_item_email(email);
node = g_list_next(node);
}
g_list_free(listDelete);
listDelete = NULL;
}
/* Add person and address data to address book.
Enter: book Address book.
folder Folder where to add person, or NULL for root folder.
listEMail New list of email addresses.
Return: Person added.
Note: A new person is created with specified list of email addresses. All objects inserted
into address book */
ItemPerson *addrbook_add_address_list(AddressBookFile *book, ItemFolder *folder,
GList *listEMail)
{
ItemPerson *person;
ItemFolder *f = folder;
GList *node;
g_return_val_if_fail(book != NULL, NULL);
if (!f)
f = book->addressCache->rootFolder;
person = addritem_create_item_person();
addrcache_id_person(book->addressCache, person);
addrcache_folder_add_person(book->addressCache, f, person);
node = listEMail;
while (node) {
ItemEMail *email = node->data;
if (ADDRITEM_ID(email) == NULL)
addrcache_id_email(book->addressCache, email);
addrcache_person_add_email(book->addressCache, person, email);
node = g_list_next(node);
}
return person;
}
/* Build available email list visitor function */
static void addrbook_build_avail_email_vis(gpointer key, gpointer value,
gpointer data)
{
AddrItemObject *obj = (AddrItemObject *) value;
if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON) {
AddressBookFile *book = data;
ItemPerson *person = (ItemPerson *) obj;
GList *node = person->listEMail;
while (node) {
ItemEMail *email = node->data;
/* gchar *newKey = g_strdup( ADDRITEM_ID(email) ); */
if (!g_hash_table_lookup(book->tempHash,
ADDRITEM_ID(email)))
book->tempList = g_list_append(book->tempList, email);
node = g_list_next(node);
}
}
}
/* Return link list of available email items (which have not already been linked to
groups). Note that the list contains references to items and should be g_free()
when done. Do *NOT* attempt to used the addrbook_free_xxx() functions... this will
destroy the addressbook data!
Return: List of items, or NULL if none */
GList *addrbook_get_available_email_list(AddressBookFile *book, ItemGroup *group)
{
GList *list = NULL;
GHashTable *table;
g_return_val_if_fail(book != NULL, NULL);
/* Load hash table with group email entries */
table = g_hash_table_new(g_str_hash, g_str_equal);
if (group) {
list = group->listEMail;
while (list) {
ItemEMail *email = list->data;
g_hash_table_insert(table, ADDRITEM_ID(email), email);
list = g_list_next(list);
}
}
/* Build list of available email addresses which exclude those already in groups */
book->tempList = NULL;
book->tempHash = table;
g_hash_table_foreach(book->addressCache->itemHash,
addrbook_build_avail_email_vis, book);
list = book->tempList;
book->tempList = NULL;
book->tempHash = NULL;
/* Clear hash table */
g_hash_table_destroy(table);
table = NULL;
return list;
}
/* Update address book email list for specified group.
Enter: book Address book.
group group to update.
listEMail New list of email addresses. This should *NOT* be g_free() when done.
Note: The existing email addresses are replaced with the new addresses. Any references
to old addresses in the groups are re-linked to the new addresses. All old addresses
linked to the person are removed */
void addrbook_update_group_list(AddressBookFile *book, ItemGroup *group,
GList *listEMail)
{
GList *oldData;
g_return_if_fail(book != NULL);
g_return_if_fail(group != NULL);
addrcache_set_dirty(book->addressCache, TRUE);
/* Remember old list */
oldData = group->listEMail;
group->listEMail = listEMail;
mgu_clear_list(oldData);
oldData = NULL;
}
/* Add group and email list to address book.
Enter: book Address book.
folder Parent folder, or NULL for root folder.
listEMail New list of email addresses. This should *NOT* be g_free() when done.
Return: Group object.
Note: The existing email addresses are replaced with the new addresses. Any references
to old addresses in the groups are re-linked to the new addresses. All old addresses
linked to the person are removed */
ItemGroup *addrbook_add_group_list(AddressBookFile *book, ItemFolder *folder,
GList *listEMail)
{
ItemGroup *group = NULL;
ItemFolder *f = folder;
g_return_val_if_fail(book != NULL, NULL);
if (!f)
f = book->addressCache->rootFolder;
group = addritem_create_item_group();
addrcache_id_group(book->addressCache, group);
addrcache_folder_add_group(book->addressCache, f, group);
group->listEMail = listEMail;
return group;
}
/* Add new folder to address book.
Enter: book Address book.
parent Parent folder.
Return: Folder that was added. This should *NOT* be g_free() when done */
ItemFolder *addrbook_add_new_folder(AddressBookFile *book, ItemFolder *parent)
{
ItemFolder *folder = NULL;
ItemFolder *p = parent;
g_return_val_if_fail(book != NULL, NULL);
if (!p)
p = book->addressCache->rootFolder;
folder = addritem_create_item_folder();
addrcache_id_folder(book->addressCache, folder);
if (addrcache_hash_add_folder(book->addressCache, folder)) {
p->listFolder = g_list_append(p->listFolder, folder);
ADDRITEM_PARENT(folder) = ADDRITEM_OBJECT(p);
addrcache_set_dirty(book->addressCache, TRUE);
}
else {
addritem_free_item_folder(folder);
folder = NULL;
}
return folder;
}
/* Update address book attribute list for specified person.
Enter: book Address book.
person Person to update.
listAttrib New list of attributes.
Note: The existing email addresses are replaced with the new addresses. All old attributes
linked to the person are removed */
void addrbook_update_attrib_list(AddressBookFile *book, ItemPerson *person,
GList *listAttrib)
{
GList *node;
GList *oldData;
g_return_if_fail(book != NULL);
g_return_if_fail(person != NULL);
/* Remember old list */
oldData = person->listAttrib;
/* Attach new address list to person. */
node = listAttrib;
while (node) {
UserAttribute *attrib = node->data;
if (attrib->uid == NULL) {
/* Allocate an ID */
addrcache_id_attribute(book->addressCache, attrib);
}
node = g_list_next(node);
}
person->listAttrib = listAttrib;
addrcache_set_dirty(book->addressCache, TRUE);
/* Free up old data */
addritem_free_list_attribute(oldData);
oldData = NULL;
}
/*
* Add attribute data for person to address book.
* Enter: book Address book.
* person New person object.
* listAttrib New list of attributes.
* Note: Only attributes are inserted into address book.
*/
void addrbook_add_attrib_list( AddressBookFile *book, ItemPerson *person, GList *listAttrib ) {
GList *node;
g_return_if_fail( book != NULL );
g_return_if_fail( person != NULL );
node = listAttrib;
while( node ) {
UserAttribute *attrib = node->data;
if( attrib->uid == NULL ) {
addrcache_id_attribute( book->addressCache, attrib );
}
addritem_person_add_attribute( person, attrib );
node = g_list_next( node );
}
addrcache_set_dirty( book->addressCache, TRUE );
}
/* Return address book file for specified object.
Enter: aio Book item object.
Return: Address book, or NULL if not found */
AddressBookFile *addrbook_item_get_bookfile(AddrItemObject *aio)
{
AddressBookFile *book = NULL;
if (aio) {
ItemFolder *parent = NULL;
ItemFolder *root = NULL;
if (aio->type == ITEMTYPE_EMAIL) {
ItemPerson *person = (ItemPerson *)ADDRITEM_PARENT(aio);
if( person )
parent = (ItemFolder *)ADDRITEM_PARENT(person);
}
else {
parent = (ItemFolder *)ADDRITEM_PARENT(aio);
}
if (parent)
root = addrcache_find_root_folder(parent);
if (root)
book = (AddressBookFile *)ADDRITEM_PARENT(root);
}
return book;
}
/* Remove folder from address book. Children are re-parented to parent folder.
param: folder Folder to remove.
return: Folder, or NULL if not found. Note that object should still be freed */
ItemFolder *addrbook_remove_folder(AddressBookFile *book, ItemFolder *folder)
{
ItemFolder *f;
g_return_val_if_fail(book != NULL, NULL);
f = addrcache_remove_folder(book->addressCache, folder);
return f;
}
/* Remove folder from address book. Children are deleted.
param: folder Folder to remove.
return: Folder, or NULL if not found. Note that object should still be freed */
ItemFolder *addrbook_remove_folder_delete(AddressBookFile *book,
ItemFolder *folder)
{
ItemFolder *f;
g_return_val_if_fail(book != NULL, NULL);
f = addrcache_remove_folder_delete(book->addressCache, folder);
return f;
}
#define WORK_BUFLEN 1024
#define ADDRBOOK_DIGITS "0123456789"
/* Return list of existing address book files.
Enter: book Address book file.
Return: File list */
GList *addrbook_get_bookfile_list(AddressBookFile *book) {
gchar *adbookdir;
DIR *dp;
struct dirent *entry;
struct stat statbuf;
gchar buf[WORK_BUFLEN];
gchar numbuf[WORK_BUFLEN];
gint len, lenpre, lensuf, lennum;
long int val, maxval;
GList *fileList = NULL;
g_return_val_if_fail(book != NULL, NULL);
if (book->path == NULL || *book->path == '\0') {
book->retVal = MGU_NO_PATH;
return NULL;
}
strcpy(buf, book->path);
len = strlen(buf);
if (len > 0) {
if (buf[len-1] != G_DIR_SEPARATOR) {
buf[len] = G_DIR_SEPARATOR;
buf[++len] = '\0';
}
}
adbookdir = g_strdup(buf);
strcat(buf, ADDRBOOK_PREFIX);
if ((dp = opendir(adbookdir)) == NULL) {
book->retVal = MGU_OPEN_DIRECTORY;
g_free(adbookdir);
return NULL;
}
lenpre = strlen(ADDRBOOK_PREFIX);
lensuf = strlen(ADDRBOOK_SUFFIX);
lennum = FILE_NUMDIGITS + lenpre;
maxval = -1;
while ((entry = readdir(dp)) != NULL) {
gchar *endptr = NULL;
gint i;
gboolean flg;
strcpy(buf, adbookdir);
strcat(buf, entry->d_name);
stat(buf, &statbuf);
if (S_IFREG & statbuf.st_mode) {
if (strncmp(entry->d_name, ADDRBOOK_PREFIX, lenpre) == 0) {
if (strncmp((entry->d_name) + lennum, ADDRBOOK_SUFFIX, lensuf) == 0) {
strncpy(numbuf, (entry->d_name) + lenpre, FILE_NUMDIGITS);
numbuf[FILE_NUMDIGITS] = '\0';
flg = TRUE;
for(i = 0; i < FILE_NUMDIGITS; i++) {
if(!strchr(ADDRBOOK_DIGITS, numbuf[i])) {
flg = FALSE;
break;
}
}
if (flg) {
/* Get value */
val = strtol(numbuf, &endptr, 10);
if (endptr && val > -1) {
if (val > maxval) maxval = val;
fileList = g_list_append(fileList, g_strdup(entry->d_name));
}
}
}
}
}
}
closedir(dp);
g_free(adbookdir);
book->maxValue = maxval;
book->retVal = MGU_SUCCESS;
return fileList;
}
/* Return file name for specified file number.
Enter: fileNum File number.
Return: File name, or NULL if file number too large. Should be g_free() when done */
gchar *addrbook_gen_new_file_name(gint fileNum) {
gchar fmt[30];
gchar buf[WORK_BUFLEN];
gint n = fileNum;
long int nmax;
if (n < 1)
n = 1;
nmax = -1 + (long int) pow(10, FILE_NUMDIGITS);
if (fileNum > nmax)
return NULL;
g_snprintf(fmt, sizeof(fmt), "%%s%%0%dd%%s", FILE_NUMDIGITS);
g_snprintf(buf, sizeof(buf), fmt, ADDRBOOK_PREFIX, n, ADDRBOOK_SUFFIX);
return g_strdup(buf);
}
/* **********************************************************************
Address book test functions...
**********************************************************************
*/
/*
* Test email address list.
*/
static void addrbook_chkparse_addr_list( AddressBookFile *book, XMLFile *file ){
guint prev_level;
GList *attr;
for (;;) {
prev_level = file->level;
if (xml_parse_next_tag(file))
longjmp(book->jumper, 1);
if (file->level < prev_level)
return;
attr = xml_get_current_tag_attr(file);
/* addrbook_show_attribs( attr ); */
if (xml_compare_tag(file, AB_ELTAG_ADDRESS))
addrbook_chkparse_addr_list(book, file);
}
}
/* Test user attributes for person */
static void addrbook_chkparse_attribute(AddressBookFile *book, XMLFile *file)
{
GList *attr;
gchar *element;
attr = xml_get_current_tag_attr(file);
/* addrbook_show_attribs( attr ); */
element = xml_get_element(file);
/* printf( "\t\tattrib value : %s\n", element ); */
}
/* Test attribute list */
static void addrbook_chkparse_attr_list(AddressBookFile *book, XMLFile *file)
{
guint prev_level;
for (;;) {
prev_level = file->level;
if (xml_parse_next_tag(file))
longjmp(book->jumper, 1);
if (file->level < prev_level)
return;
if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE)) {
addrbook_chkparse_attribute(book, file);
addrbook_chkparse_attr_list(book, file);
}
}
}
/* Test person */
static void addrbook_chkparse_person(AddressBookFile *book, XMLFile *file)
{
GList *attr;
attr = xml_get_current_tag_attr(file);
/* addrbook_show_attribs( attr ); */
if (xml_parse_next_tag(file)) /* Consume closing tag */
longjmp(book->jumper, 1);
if (xml_compare_tag(file, AB_ELTAG_ADDRESS_LIST))
addrbook_chkparse_addr_list(book, file);
if (xml_parse_next_tag(file)) /* Consume closing tag */
longjmp(book->jumper, 1);
if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE_LIST))
addrbook_chkparse_attr_list(book, file);
}
/* Test group member list */
static void addrbook_chkparse_member_list(AddressBookFile *book, XMLFile *file)
{
GList *attr;
guint prev_level;
for (;;) {
prev_level = file->level;
if (xml_parse_next_tag(file))
longjmp(book->jumper, 1);
if (file->level < prev_level)
return;
if (xml_compare_tag(file, AB_ELTAG_MEMBER)) {
attr = xml_get_current_tag_attr(file);
/* addrbook_show_attribs( attr ); */
addrbook_chkparse_member_list(book, file);
}
else {
attr = xml_get_current_tag_attr(file);
/* addrbook_show_attribs( attr ); */
}
}
}
/* Test group */
static void addrbook_chkparse_group(AddressBookFile *book, XMLFile *file)
{
GList *attr;
attr = xml_get_current_tag_attr(file);
/* addrbook_show_attribs( attr ); */
if (xml_parse_next_tag(file)) /* Consume closing tag */
longjmp(book->jumper, 1);
if (xml_compare_tag(file, AB_ELTAG_MEMBER_LIST))
addrbook_chkparse_member_list(book, file);
}
/* Test folder item list */
static void addrbook_chkparse_folder_list(AddressBookFile *book, XMLFile *file)
{
GList *attr;
guint prev_level;
for (;;) {
prev_level = file->level;
if (xml_parse_next_tag(file))
longjmp(book->jumper, 1);
if (file->level < prev_level)
return;
if (xml_compare_tag(file, AB_ELTAG_ITEM)) {
attr = xml_get_current_tag_attr(file);
/* addrbook_show_attribs( attr ); */
addrbook_chkparse_folder_list(book, file);
}
else {
attr = xml_get_current_tag_attr(file);
/* addrbook_show_attribs( attr ); */
}
}
}
/* Test folder */
static void addrbook_chkparse_folder(AddressBookFile *book, XMLFile *file)
{
GList *attr;
attr = xml_get_current_tag_attr(file);
/* addrbook_show_attribs( attr ); */
if (xml_parse_next_tag(file)) /* Consume closing tag */
longjmp(book->jumper, 1);
if (xml_compare_tag(file, AB_ELTAG_ITEM_LIST))
addrbook_chkparse_folder_list(book, file);
}
/* Test address book */
static gboolean addrbook_chkread_tree(AddressBookFile *book, XMLFile *file)
{
GList *attr;
gboolean retVal;
if (xml_get_dtd(file))
return FALSE;
if (xml_parse_next_tag(file))
return FALSE;
if (!xml_compare_tag(file, AB_ELTAG_ADDRESS_BOOK))
return FALSE;
attr = xml_get_current_tag_attr(file);
/* addrbook_show_attribs( attr ); */
retVal = TRUE;
for (;;) {
if (!file->level)
break;
/* Get item tag */
if (xml_parse_next_tag(file))
longjmp(book->jumper, 1);
/* Get next tag (person, group or folder) */
if (xml_compare_tag(file, AB_ELTAG_PERSON))
addrbook_chkparse_person( book, file );
else if (xml_compare_tag(file, AB_ELTAG_GROUP))
addrbook_chkparse_group(book, file);
else if (xml_compare_tag(file, AB_ELTAG_FOLDER))
addrbook_chkparse_folder(book, file);
}
return retVal;
}
/* Test address book file by parsing contents.
Enter: book Address book file to check.
fileName File name to check.
Return: MGU_SUCCESS if file appears to be valid format */
gint addrbook_test_read_file(AddressBookFile *book, gchar *fileName)
{
XMLFile *file = NULL;
gchar *fileSpec = NULL;
g_return_val_if_fail(book != NULL, -1);
fileSpec = g_strconcat(book->path, G_DIR_SEPARATOR_S, fileName, NULL);
book->retVal = MGU_OPEN_FILE;
file = xml_open_file(fileSpec);
g_free(fileSpec);
if (file) {
book->retVal = MGU_BAD_FORMAT;
if (setjmp(book->jumper)) {
/* printf( "Caught Ya!!!\n" ); */
xml_close_file(file);
return book->retVal;
}
if (addrbook_chkread_tree(book, file))
book->retVal = MGU_SUCCESS;
xml_close_file( file );
}
return book->retVal;
}
/* Return link list of all persons in address book. Note that the list contains
references to items. Do *NOT* attempt to use the addrbook_free_xxx() functions...
this will destroy the addressbook data!
Return: List of items, or NULL if none */
GList *addrbook_get_all_persons(AddressBookFile *book)
{
g_return_val_if_fail(book != NULL, NULL);
return addrcache_get_all_persons(book->addressCache);
}
/**
* Add person and address data to address book.
* \param book Address book.
* \param folder Folder where to add person, or NULL for root folder.
* \param name Common name.
* \param address EMail address.
* \param remarks Remarks.
* \return Person added. Do not <b>*NOT*</b> to use the
* <code>addrbook_free_xxx()</code> functions... this will destroy
* the address book data.
*/
ItemPerson *addrbook_add_contact(AddressBookFile *book, ItemFolder *folder,
const gchar *name,const gchar *address,
const gchar *remarks)
{
ItemPerson *person;
g_return_val_if_fail(book != NULL, NULL);
person = addrcache_add_contact(
book->addressCache, folder, name, address, remarks );
addrcache_invalidate( book->addressCache );
return person;
}
/**
* Return file name for next address book file.
* \param book Address book.
* \return File name, or <i>NULL</i> if could not create. This should be
* <code>g_free()</code> when done.
*/
gchar *addrbook_guess_next_file(AddressBookFile *book)
{
gchar *newFile = NULL;
GList *fileList = NULL;
gint fileNum = 1;
fileList = addrbook_get_bookfile_list(book);
if (fileList)
fileNum = 1 + book->maxValue;
newFile = addrbook_gen_new_file_name(fileNum);
g_list_free(fileList);
fileList = NULL;
return newFile;
}
/**
* Invalidate the address book data. This will cause index to be rebuilt.
* \param book Address book.
*/
void addrbook_invalidate( AddressBookFile *book ) {
g_return_if_fail( book != NULL );
addrcache_invalidate( book->addressCache );
}
/*
* End of Source.
*/
Reference in a new issue View git blame Copy permalink