2007-02-23 [wwp] 2.7.2cvs66
[claws.git] / src / addrindex.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 2 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, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  */
19
20 /*
21  * General functions for accessing address index file.
22  */
23
24 #ifdef HAVE_CONFIG_H
25 #  include "config.h"
26 #endif
27
28 #include "defs.h"
29
30 #include <glib.h>
31 #include <glib/gi18n.h>
32
33 #include "mgutils.h"
34 #include "addritem.h"
35 #include "addrcache.h"
36 #include "addrbook.h"
37 #include "addressbook.h"
38 #include "addrindex.h"
39 #include "xml.h"
40 #include "addrquery.h"
41 #include "addr_compl.h"
42 #include "utils.h"
43
44 #ifndef DEV_STANDALONE
45 #include "prefs_gtk.h"
46 #include "codeconv.h"
47 #endif
48
49 #include "vcard.h"
50
51 #ifdef USE_JPILOT
52 #include "jpilot.h"
53 #endif
54
55 #ifdef USE_LDAP
56 #include "ldapserver.h"
57 #include "ldapctrl.h"
58 #include "ldapquery.h"
59 #include "ldaputil.h"
60 #endif
61
62 #define TAG_ADDRESS_INDEX    "addressbook"
63
64 #define TAG_IF_ADDRESS_BOOK  "book_list"
65 #define TAG_IF_VCARD         "vcard_list"
66 #define TAG_IF_JPILOT        "jpilot_list"
67 #define TAG_IF_LDAP          "ldap_list"
68
69 #define TAG_DS_ADDRESS_BOOK  "book"
70 #define TAG_DS_VCARD         "vcard"
71 #define TAG_DS_JPILOT        "jpilot"
72 #define TAG_DS_LDAP          "server"
73
74 /* XML Attribute names */
75 #define ATTAG_BOOK_NAME       "name"
76 #define ATTAG_BOOK_FILE       "file"
77
78 #define ATTAG_VCARD_NAME      "name"
79 #define ATTAG_VCARD_FILE      "file"
80
81 #define ATTAG_JPILOT_NAME     "name"
82 #define ATTAG_JPILOT_FILE     "file"
83 #define ATTAG_JPILOT_CUSTOM_1 "custom-1"
84 #define ATTAG_JPILOT_CUSTOM_2 "custom-2"
85 #define ATTAG_JPILOT_CUSTOM_3 "custom-3"
86 #define ATTAG_JPILOT_CUSTOM_4 "custom-4"
87 #define ATTAG_JPILOT_CUSTOM   "custom-"
88
89 #define ATTAG_LDAP_NAME       "name"
90 #define ATTAG_LDAP_HOST       "host"
91 #define ATTAG_LDAP_PORT       "port"
92 #define ATTAG_LDAP_BASE_DN    "base-dn"
93 #define ATTAG_LDAP_BIND_DN    "bind-dn"
94 #define ATTAG_LDAP_BIND_PASS  "bind-pass"
95 #define ATTAG_LDAP_CRITERIA   "criteria"
96 #define ATTAG_LDAP_MAX_ENTRY  "max-entry"
97 #define ATTAG_LDAP_TIMEOUT    "timeout"
98 #define ATTAG_LDAP_MAX_AGE    "max-age"
99 #define ATTAG_LDAP_DYN_SEARCH "dyn-search"
100 #define ATTAG_LDAP_MATCH_OPT  "match-opt"
101 #define ATTAG_LDAP_ENABLE_TLS "enable-tls"
102 #define ATTAG_LDAP_ENABLE_SSL "enable-ssl"
103
104 #define ELTAG_LDAP_ATTR_SRCH  "attribute"
105 #define ATTAG_LDAP_ATTR_NAME  "name"
106
107 /* Attribute values */
108 #define ATVAL_BOOLEAN_YES         "yes"
109 #define ATVAL_BOOLEAN_NO          "no"
110 #define ATVAL_LDAP_MATCH_BEGIN    "begin-with"
111 #define ATVAL_LDAP_MATCH_CONTAINS "contains"
112
113 /* New attributes */
114 #define ATTAG_LDAP_DEFAULT    "default"
115
116 #define DISP_NEW_COMMON       _("Common addresses")
117 #define DISP_NEW_PERSONAL     _("Personal addresses")
118
119 /* Old address book */
120 #define TAG_IF_OLD_COMMON     "common_address"
121 #define TAG_IF_OLD_PERSONAL   "personal_address"
122
123 #define DISP_OLD_COMMON       _("Common address")
124 #define DISP_OLD_PERSONAL     _("Personal address")
125
126 /**
127  * Singleton object.
128  */
129 static AddressIndex *_addressIndex_ = NULL;
130
131 /*
132  * Define attribute name-value pair.
133  */
134 typedef struct _AddressIfAttr AddressIfAttrib;
135 struct _AddressIfAttr {
136         gchar *name;
137         gchar *value;
138 };
139
140 static AddressDataSource *addrindex_create_datasource   ( AddressIfType ifType );
141
142 static GList *addrindex_ds_get_all_persons      ( AddressDataSource *ds );
143 static GList *addrindex_ds_get_all_groups       ( AddressDataSource *ds );
144 static AddressDataSource *addrindex_get_datasource      ( AddressIndex *addrIndex,
145                                                   const gchar *cacheID );
146 static AddressInterface *addrindex_get_interface        ( AddressIndex *addrIndex,
147                                                   AddressIfType ifType );
148 static gint addrindex_write_to                  ( AddressIndex *addrIndex,
149                                           const gchar *newFile );
150
151 /*
152  * Define DOM fragment.
153  */
154 typedef struct _AddressIfFrag AddressIfFragment;
155 struct _AddressIfFrag {
156         gchar *name;
157         GList *children;
158         GList *attributes;
159 };
160
161 /**
162  * Build interface with default values.
163  *
164  * \param type Interface type.
165  * \param name Interface name.
166  * \param tagIf XML tag name for interface in address index file.
167  * \param tagDS XML tag name for datasource in address index file.
168  * \return Address interface object.
169 */
170 static AddressInterface *addrindex_create_interface(
171                 gint type, gchar *name, gchar *tagIf, gchar *tagDS )
172 {
173         AddressInterface *iface = g_new0( AddressInterface, 1 );
174
175         ADDRITEM_TYPE(iface) = ITEMTYPE_INTERFACE;
176         ADDRITEM_ID(iface) = NULL;
177         ADDRITEM_NAME(iface) = g_strdup( name );
178         ADDRITEM_PARENT(iface) = NULL;
179         ADDRITEM_SUBTYPE(iface) = type;
180         iface->type = type;
181         iface->name = g_strdup( name );
182         iface->listTag = g_strdup( tagIf );
183         iface->itemTag = g_strdup( tagDS );
184         iface->legacyFlag = FALSE;
185         iface->haveLibrary = TRUE;
186         iface->useInterface = TRUE;
187         iface->readOnly      = TRUE;
188
189         /* Set callbacks to NULL values - override for each interface */
190         iface->getAccessFlag = NULL;
191         iface->getModifyFlag = NULL;
192         iface->getReadFlag   = NULL;
193         iface->getStatusCode = NULL;
194         iface->getReadData   = NULL;
195         iface->getRootFolder = NULL;
196         iface->getListFolder = NULL;
197         iface->getListPerson = NULL;
198         iface->getAllPersons = NULL;
199         iface->getAllGroups  = NULL;
200         iface->getName       = NULL;
201         iface->listSource = NULL;
202
203         /* Search stuff */
204         iface->externalQuery = FALSE;
205         iface->searchOrder = 0;         /* Ignored */
206         iface->startSearch = NULL;
207         iface->stopSearch = NULL;
208
209         return iface;
210 }
211
212 /**
213  * Build table of of all address book interfaces.
214  * \param addrIndex Address index object.
215  */
216 static void addrindex_build_if_list( AddressIndex *addrIndex ) {
217         AddressInterface *iface;
218
219         /* Create intrinsic XML address book interface */
220         iface = addrindex_create_interface(
221                         ADDR_IF_BOOK, "Address Book", TAG_IF_ADDRESS_BOOK,
222                         TAG_DS_ADDRESS_BOOK );
223         iface->readOnly      = FALSE;
224         iface->getModifyFlag = ( void * ) addrbook_get_modified;
225         iface->getAccessFlag = ( void * ) addrbook_get_accessed;
226         iface->getReadFlag   = ( void * ) addrbook_get_read_flag;
227         iface->getStatusCode = ( void * ) addrbook_get_status;
228         iface->getReadData   = ( void * ) addrbook_read_data;
229         iface->getRootFolder = ( void * ) addrbook_get_root_folder;
230         iface->getListFolder = ( void * ) addrbook_get_list_folder;
231         iface->getListPerson = ( void * ) addrbook_get_list_person;
232         iface->getAllPersons = ( void * ) addrbook_get_all_persons;
233         iface->getAllGroups  = ( void * ) addrbook_get_all_groups;
234         iface->getName       = ( void * ) addrbook_get_name;
235         iface->setAccessFlag = ( void * ) addrbook_set_accessed;
236         iface->searchOrder   = 0;
237
238         /* Add to list of interfaces in address book */ 
239         addrIndex->interfaceList =
240                 g_list_append( addrIndex->interfaceList, iface );
241         ADDRITEM_PARENT(iface) = ADDRITEM_OBJECT(addrIndex);
242
243         /* Create vCard interface */
244         iface = addrindex_create_interface(
245                         ADDR_IF_VCARD, "vCard", TAG_IF_VCARD, TAG_DS_VCARD );
246         iface->getModifyFlag = ( void * ) vcard_get_modified;
247         iface->getAccessFlag = ( void * ) vcard_get_accessed;
248         iface->getReadFlag   = ( void * ) vcard_get_read_flag;
249         iface->getStatusCode = ( void * ) vcard_get_status;
250         iface->getReadData   = ( void * ) vcard_read_data;
251         iface->getRootFolder = ( void * ) vcard_get_root_folder;
252         iface->getListFolder = ( void * ) vcard_get_list_folder;
253         iface->getListPerson = ( void * ) vcard_get_list_person;
254         iface->getAllPersons = ( void * ) vcard_get_all_persons;
255         iface->getName       = ( void * ) vcard_get_name;
256         iface->setAccessFlag = ( void * ) vcard_set_accessed;
257         iface->searchOrder   = 0;
258         addrIndex->interfaceList =
259                 g_list_append( addrIndex->interfaceList, iface );
260         ADDRITEM_PARENT(iface) = ADDRITEM_OBJECT(addrIndex);
261
262         /* Create JPilot interface */
263         iface = addrindex_create_interface(
264                         ADDR_IF_JPILOT, "J-Pilot", TAG_IF_JPILOT,
265                         TAG_DS_JPILOT );
266 #ifdef USE_JPILOT
267         iface->haveLibrary = jpilot_test_pilot_lib();
268         iface->useInterface = iface->haveLibrary;
269         iface->getModifyFlag = ( void * ) jpilot_get_modified;
270         iface->getAccessFlag = ( void * ) jpilot_get_accessed;
271         iface->getReadFlag   = ( void * ) jpilot_get_read_flag;
272         iface->getStatusCode = ( void * ) jpilot_get_status;
273         iface->getReadData   = ( void * ) jpilot_read_data;
274         iface->getRootFolder = ( void * ) jpilot_get_root_folder;
275         iface->getListFolder = ( void * ) jpilot_get_list_folder;
276         iface->getListPerson = ( void * ) jpilot_get_list_person;
277         iface->getAllPersons = ( void * ) jpilot_get_all_persons;
278         iface->getName       = ( void * ) jpilot_get_name;
279         iface->setAccessFlag = ( void * ) jpilot_set_accessed;
280         iface->searchOrder   = 0;
281 #else
282         iface->useInterface = FALSE;
283         iface->haveLibrary = FALSE;
284 #endif
285         addrIndex->interfaceList =
286                 g_list_append( addrIndex->interfaceList, iface );
287         ADDRITEM_PARENT(iface) = ADDRITEM_OBJECT(addrIndex);
288
289         /* Create LDAP interface */
290         iface = addrindex_create_interface(
291                         ADDR_IF_LDAP, "LDAP", TAG_IF_LDAP, TAG_DS_LDAP );
292 #ifdef USE_LDAP
293         /* iface->haveLibrary = ldapsvr_test_ldap_lib(); */
294         iface->haveLibrary = ldaputil_test_ldap_lib();
295         iface->useInterface = iface->haveLibrary;
296         /* iface->getModifyFlag = ( void * ) ldapsvr_get_modified; */
297         iface->getAccessFlag = ( void * ) ldapsvr_get_accessed;
298         /* iface->getReadFlag   = ( void * ) ldapsvr_get_read_flag; */
299         iface->getStatusCode = ( void * ) ldapsvr_get_status;
300         /* iface->getReadData   = ( void * ) ldapsvr_read_data; */
301         iface->getRootFolder = ( void * ) ldapsvr_get_root_folder;
302         iface->getListFolder = ( void * ) ldapsvr_get_list_folder;
303         iface->getListPerson = ( void * ) ldapsvr_get_list_person;
304         iface->getName       = ( void * ) ldapsvr_get_name;
305         iface->setAccessFlag = ( void * ) ldapsvr_set_accessed;
306         iface->externalQuery = TRUE;
307         iface->searchOrder   = 1;
308 #else
309         iface->useInterface = FALSE;
310         iface->haveLibrary = FALSE;
311 #endif
312         addrIndex->interfaceList =
313                 g_list_append( addrIndex->interfaceList, iface );
314         ADDRITEM_PARENT(iface) = ADDRITEM_OBJECT(addrIndex);
315
316         /* Two old legacy data sources (pre 0.7.0) */
317         iface = addrindex_create_interface(
318                         ADDR_IF_COMMON, "Old Address - common",
319                         TAG_IF_OLD_COMMON, NULL );
320         iface->legacyFlag = TRUE;
321         addrIndex->interfaceList =
322                 g_list_append( addrIndex->interfaceList, iface );
323         ADDRITEM_PARENT(iface) = ADDRITEM_OBJECT(addrIndex);
324
325         iface = addrindex_create_interface(
326                         ADDR_IF_COMMON, "Old Address - personal",
327                         TAG_IF_OLD_PERSONAL, NULL );
328         iface->legacyFlag = TRUE;
329         addrIndex->interfaceList =
330                 g_list_append( addrIndex->interfaceList, iface );
331         ADDRITEM_PARENT(iface) = ADDRITEM_OBJECT(addrIndex);
332
333 }
334
335 /**
336  * Free DOM fragment.
337  * \param fragment Fragment to free.
338  */
339 static void addrindex_free_fragment( AddressIfFragment *fragment ) {
340         GList *node;
341
342         /* Free children */
343         node = fragment->children;
344         while( node ) {
345                 AddressIfFragment *child = node->data;
346                 addrindex_free_fragment( child );
347                 node->data = NULL;
348                 node = g_list_next( node );
349         }
350         g_list_free( fragment->children );
351
352         /* Free attributes */
353         node = fragment->attributes;
354         while( node ) {
355                 AddressIfAttrib *nv = node->data;
356                 g_free( nv->name );
357                 g_free( nv->value );
358                 g_free( nv );
359                 node->data = NULL;
360                 node = g_list_next( node );
361         }
362         g_list_free( fragment->attributes );
363
364         g_free( fragment->name );
365         fragment->name = NULL;
366         fragment->attributes = NULL;
367         fragment->children = NULL;
368
369         g_free( fragment );
370 }
371
372 /**
373  * Create a new data source.
374  * \param ifType Interface type to create.
375  * \return Initialized data source.
376  */
377 AddressDataSource *addrindex_create_datasource( AddressIfType ifType ) {
378         AddressDataSource *ds = g_new0( AddressDataSource, 1 );
379
380         ADDRITEM_TYPE(ds) = ITEMTYPE_DATASOURCE;
381         ADDRITEM_ID(ds) = NULL;
382         ADDRITEM_NAME(ds) = NULL;
383         ADDRITEM_PARENT(ds) = NULL;
384         ADDRITEM_SUBTYPE(ds) = 0;
385         ds->type = ifType;
386         ds->rawDataSource = NULL;
387         ds->interface = NULL;
388         return ds;
389 }
390
391 /**
392  * Free up data source.
393  * \param ds Data source to free.
394  */
395 void addrindex_free_datasource( AddressDataSource *ds ) {
396         AddressInterface *iface;
397
398         g_return_if_fail( ds != NULL );
399
400         iface = ds->interface;
401         if( ds->rawDataSource != NULL ) {
402                 if( iface != NULL ) {
403                         if( iface->useInterface ) {
404                                 if( iface->type == ADDR_IF_BOOK ) {
405                                         AddressBookFile *abf = ds->rawDataSource;
406                                         addrbook_free_book( abf );
407                                 }
408                                 else if( iface->type == ADDR_IF_VCARD ) {
409                                         VCardFile *vcf = ds->rawDataSource;
410                                         vcard_free( vcf );
411                                 }
412 #ifdef USE_JPILOT
413                                 else if( iface->type == ADDR_IF_JPILOT ) {
414                                         JPilotFile *jpf = ds->rawDataSource;
415                                         jpilot_free( jpf );
416                                 }
417 #endif
418 #ifdef USE_LDAP
419                                 else if( iface->type == ADDR_IF_LDAP ) {
420                                         LdapServer *server = ds->rawDataSource;
421                                         ldapsvr_free( server );
422                                 }
423 #endif
424                                 else {
425                                 }
426                         }
427                         else {
428                                 AddressIfFragment *fragment = ds->rawDataSource;
429                                 addrindex_free_fragment( fragment );
430                         }
431                 }
432         }
433
434         ADDRITEM_TYPE(ds) = ITEMTYPE_NONE;
435         ADDRITEM_ID(ds) = NULL;
436         ADDRITEM_NAME(ds) = NULL;
437         ADDRITEM_PARENT(ds) = NULL;
438         ADDRITEM_SUBTYPE(ds) = 0;
439         ds->type = ADDR_IF_NONE;
440         ds->interface = NULL;
441         ds->rawDataSource = NULL;
442
443         g_free( ds );
444 }
445
446 /**
447  * Free up all data sources for specified interface.
448  * \param iface Address interface to process.
449  */
450 static void addrindex_free_all_datasources( AddressInterface *iface ) {
451         GList *node = iface->listSource;
452         while( node ) {
453                 AddressDataSource *ds = node->data;
454                 addrindex_free_datasource( ds );
455                 node->data = NULL;
456                 node = g_list_next( node );
457         }
458 }
459
460 /**
461  * Free up specified interface.
462  * \param iface Interface to process.
463  */
464 static void addrindex_free_interface( AddressInterface *iface ) {
465         /* Free up data sources */
466         addrindex_free_all_datasources( iface );
467         g_list_free( iface->listSource );
468
469         /* Free internal storage */
470         g_free( ADDRITEM_ID(iface) );
471         g_free( ADDRITEM_NAME(iface) );
472         g_free( iface->name );
473         g_free( iface->listTag );
474         g_free( iface->itemTag );
475
476         /* Clear all pointers */
477         ADDRITEM_TYPE(iface) = ITEMTYPE_NONE;
478         ADDRITEM_ID(iface) = NULL;
479         ADDRITEM_NAME(iface) = NULL;
480         ADDRITEM_PARENT(iface) = NULL;
481         ADDRITEM_SUBTYPE(iface) = 0;
482         iface->type = ADDR_IF_NONE;
483         iface->name = NULL;
484         iface->listTag = NULL;
485         iface->itemTag = NULL;
486         iface->legacyFlag = FALSE;
487         iface->useInterface = FALSE;
488         iface->haveLibrary = FALSE;
489         iface->listSource = NULL;
490
491         /* Search stuff */
492         iface->searchOrder = 0;
493         iface->startSearch = NULL;
494         iface->stopSearch = NULL;
495
496         g_free( iface );
497 }
498
499 /**
500  * Return cache ID for specified data source.
501  *
502  * \param  addrIndex Address index.
503  * \param  ds        Data source.
504  * \return ID or NULL if not found. This should be <code>g_free()</code>
505  *         when done.
506  */
507 gchar *addrindex_get_cache_id( AddressIndex *addrIndex, AddressDataSource *ds ) {
508         gchar *cacheID = NULL;
509         AddrBookBase *adbase;
510         AddressCache *cache;
511
512         g_return_val_if_fail( addrIndex != NULL, NULL );
513         g_return_val_if_fail( ds != NULL, NULL );
514
515         adbase = ( AddrBookBase * ) ds->rawDataSource;
516         if( adbase ) {
517                 cache = adbase->addressCache;
518                 if( cache ) {
519                         cacheID = g_strdup( cache->cacheID );
520                 }
521         }
522
523         return cacheID;
524 }
525
526 /**
527  * Return reference to data source for specified cacheID.
528  * \param addrIndex Address index.
529  * \param cacheID   ID.
530  * \return Data source, or NULL if not found.
531  */
532 static AddressDataSource *addrindex_get_datasource(
533                 AddressIndex *addrIndex, const gchar *cacheID )
534 {
535         g_return_val_if_fail( addrIndex != NULL, NULL );
536         g_return_val_if_fail( cacheID != NULL, NULL );
537         return ( AddressDataSource * ) g_hash_table_lookup( addrIndex->hashCache, cacheID );
538 }
539
540 /**
541  * Return reference to address cache for specified cacheID.
542  * \param addrIndex Address index.
543  * \param cacheID   ID.
544  * \return Address cache, or NULL if not found.
545  */
546 AddressCache *addrindex_get_cache( AddressIndex *addrIndex, const gchar *cacheID ) {
547         AddressDataSource *ds;
548         AddrBookBase *adbase;
549         AddressCache *cache;
550
551         g_return_val_if_fail( addrIndex != NULL, NULL );
552         g_return_val_if_fail( cacheID != NULL, NULL );
553
554         cache = NULL;
555         ds = addrindex_get_datasource( addrIndex, cacheID );
556         if( ds ) {
557                 adbase = ( AddrBookBase * ) ds->rawDataSource;
558                 cache = adbase->addressCache;
559         }
560         return cache;
561 }
562
563 /**
564  * Add data source into hash table.
565  * \param addrIndex Address index.
566  * \param ds        Data source.
567  */
568 static void addrindex_hash_add_cache(
569                 AddressIndex *addrIndex, AddressDataSource *ds )
570 {
571         gchar *cacheID;
572
573         cacheID = addrindex_get_cache_id( addrIndex, ds );
574         if( cacheID ) {
575                 g_hash_table_insert( addrIndex->hashCache, cacheID, ds );
576         }
577 }
578
579 /*
580  * Free hash table callback function.
581  */
582 static gboolean addrindex_free_cache_cb( gpointer key, gpointer value, gpointer data ) {
583         g_free( key );
584         key = NULL;
585         value = NULL;
586         return TRUE;
587 }
588
589 /*
590  * Free hash table of address cache items.
591  */
592 static void addrindex_free_cache_hash( GHashTable *table ) {
593         g_hash_table_foreach_remove( table, addrindex_free_cache_cb, NULL );
594         g_hash_table_destroy( table );
595 }
596
597 /**
598  * Remove data source from internal hashtable.
599  * \param addrIndex Address index.
600  * \param ds        Data source to remove.
601  */
602 static void addrindex_hash_remove_cache(
603                 AddressIndex *addrIndex, AddressDataSource *ds )
604 {
605         gchar *cacheID;
606
607         cacheID = addrindex_get_cache_id( addrIndex, ds );
608         if( cacheID ) {
609                 g_hash_table_remove( addrIndex->hashCache, cacheID );
610                 g_free( cacheID );
611                 cacheID = NULL;
612         }
613 }
614
615 /**
616  * Create a new address index. This is created as a singleton object.
617  * \return Initialized address index object.
618  */
619 AddressIndex *addrindex_create_index( void ) {
620         AddressIndex *index;
621
622         if( _addressIndex_ == NULL ) {
623                 index = g_new0( AddressIndex, 1 );
624                 ADDRITEM_TYPE(index) = ITEMTYPE_INDEX;
625                 ADDRITEM_ID(index) = NULL;
626                 ADDRITEM_NAME(index) = g_strdup( "Address Index" );
627                 ADDRITEM_PARENT(index) = NULL;
628                 ADDRITEM_SUBTYPE(index) = 0;
629                 index->filePath = NULL;
630                 index->fileName = NULL;
631                 index->retVal = MGU_SUCCESS;
632                 index->needsConversion = FALSE;
633                 index->wasConverted = FALSE;
634                 index->conversionError = FALSE;
635                 index->interfaceList = NULL;
636                 index->lastType = ADDR_IF_NONE;
637                 index->dirtyFlag = FALSE;
638                 index->hashCache = g_hash_table_new( g_str_hash, g_str_equal );
639                 index->loadedFlag = FALSE;
640                 index->searchOrder = NULL;
641                 addrindex_build_if_list( index );
642                 _addressIndex_ = index;
643         }
644         return _addressIndex_;
645 }
646
647 /**
648  * Property - Specify file path to address index file.
649  * \param addrIndex Address index.
650  * \param value Path to index file.
651  */
652 void addrindex_set_file_path( AddressIndex *addrIndex, const gchar *value ) {
653         g_return_if_fail( addrIndex != NULL );
654         addrIndex->filePath = mgu_replace_string( addrIndex->filePath, value );
655 }
656
657 /**
658  * Property - Specify file name to address index file.
659  * \param addrIndex Address index.
660  * \param value File name.
661  */
662 void addrindex_set_file_name( AddressIndex *addrIndex, const gchar *value ) {
663         g_return_if_fail( addrIndex != NULL );
664         addrIndex->fileName = mgu_replace_string( addrIndex->fileName, value );
665 }
666
667 /**
668  * Return list of address interfaces.
669  * \param addrIndex Address index.
670  * \return List of address interfaces.
671  */
672 GList *addrindex_get_interface_list( AddressIndex *addrIndex ) {
673         g_return_val_if_fail( addrIndex != NULL, NULL );
674         return addrIndex->interfaceList;
675 }
676
677 /**
678  * Perform any other initialization of address index.
679  */
680 void addrindex_initialize( void ) {
681         qrymgr_initialize();
682         addrcompl_initialize();
683 }
684
685 /**
686  * Perform any other teardown of address index.
687  */
688 void addrindex_teardown( void ) {
689         addrcompl_teardown();
690         qrymgr_teardown();
691 }
692
693 /**
694  * Free up address index.
695  * \param addrIndex Address index.
696  */
697 void addrindex_free_index( AddressIndex *addrIndex ) {
698         GList *node;
699
700         g_return_if_fail( addrIndex != NULL );
701
702         /* Search stuff */
703         g_list_free( addrIndex->searchOrder );
704         addrIndex->searchOrder = NULL;
705
706         /* Free internal storage */
707         g_free( ADDRITEM_ID(addrIndex) );
708         g_free( ADDRITEM_NAME(addrIndex) );
709         g_free( addrIndex->filePath );
710         g_free( addrIndex->fileName );
711
712         /* Clear pointers */    
713         ADDRITEM_TYPE(addrIndex) = ITEMTYPE_NONE;
714         ADDRITEM_ID(addrIndex) = NULL;
715         ADDRITEM_NAME(addrIndex) = NULL;
716         ADDRITEM_PARENT(addrIndex) = NULL;
717         ADDRITEM_SUBTYPE(addrIndex) = 0;
718         addrIndex->filePath = NULL;
719         addrIndex->fileName = NULL;
720         addrIndex->retVal = MGU_SUCCESS;
721         addrIndex->needsConversion = FALSE;
722         addrIndex->wasConverted = FALSE;
723         addrIndex->conversionError = FALSE;
724         addrIndex->lastType = ADDR_IF_NONE;
725         addrIndex->dirtyFlag = FALSE;
726
727         /* Free up interfaces */        
728         node = addrIndex->interfaceList;
729         while( node ) {
730                 AddressInterface *iface = node->data;
731                 addrindex_free_interface( iface );
732                 node = g_list_next( node );
733         }
734         g_list_free( addrIndex->interfaceList );
735         addrIndex->interfaceList = NULL;
736
737         /* Free up hash cache */
738         addrindex_free_cache_hash( addrIndex->hashCache );
739         addrIndex->hashCache = NULL;
740
741         addrIndex->loadedFlag = FALSE;
742
743         g_free( addrIndex );
744         addrIndex = NULL;
745         _addressIndex_ = NULL;
746 }
747
748 /**
749  * Print address index.
750  * \param addrIndex Address index.
751  * \parem stream    Stream to print.
752 */
753 void addrindex_print_index( AddressIndex *addrIndex, FILE *stream ) {
754         g_return_if_fail( addrIndex != NULL );
755         fprintf( stream, "AddressIndex:\n" );
756         fprintf( stream, "\tfile path: '%s'\n", addrIndex->filePath );
757         fprintf( stream, "\tfile name: '%s'\n", addrIndex->fileName );
758         fprintf( stream, "\t   status: %d\n", addrIndex->retVal );
759         fprintf( stream, "\tconverted: '%s'\n",
760                         addrIndex->wasConverted ? "yes" : "no" );
761         fprintf( stream, "\tcvt error: '%s'\n",
762                         addrIndex->conversionError ? "yes" : "no" );
763         fprintf( stream, "\t---\n" );
764 }
765
766 /**
767  * Retrieve reference to address interface for specified interface type.
768  * \param  addrIndex Address index.
769  * \param  ifType Interface type.
770  * \return Address interface, or NULL if not found.
771  */
772 static AddressInterface *addrindex_get_interface(
773         AddressIndex *addrIndex, AddressIfType ifType )
774 {
775         AddressInterface *retVal = NULL;
776         GList *node;
777
778         g_return_val_if_fail( addrIndex != NULL, NULL );
779
780         node = addrIndex->interfaceList;
781         while( node ) {
782                 AddressInterface *iface = node->data;
783                 node = g_list_next( node );
784                 if( iface->type == ifType ) {
785                         retVal = iface;
786                         break;
787                 }
788         }
789         return retVal;
790 }
791
792 /**
793  * Add raw data source to index. The raw data object (an AddressBookFile or
794  * VCardFile object, for example) should be supplied as the raw dataSource
795  * argument.
796  *
797  * \param  addrIndex Address index.
798  * \param ifType     Interface type to add.
799  * \param dataSource Actual raw data source to add. 
800  * \return Data source added, or NULL if invalid interface type.
801  */
802 AddressDataSource *addrindex_index_add_datasource(
803         AddressIndex *addrIndex, AddressIfType ifType, gpointer dataSource )
804 {
805         AddressInterface *iface;
806         AddressDataSource *ds = NULL;
807
808         g_return_val_if_fail( addrIndex != NULL, NULL );
809         g_return_val_if_fail( dataSource != NULL, NULL );
810
811         iface = addrindex_get_interface( addrIndex, ifType );
812         if( iface ) {
813                 ds = addrindex_create_datasource( ifType );
814                 ADDRITEM_PARENT(ds) = ADDRITEM_OBJECT(iface);
815                 ds->type = ifType;
816                 ds->rawDataSource = dataSource;
817                 ds->interface = iface;
818                 iface->listSource = g_list_append( iface->listSource, ds );
819                 addrIndex->dirtyFlag = TRUE;
820
821                 addrindex_hash_add_cache( addrIndex, ds );
822         }
823         return ds;
824 }
825
826 /**
827  * Remove specified data source from index.
828  * \param  addrIndex Address index.
829  * \param  dataSource Data source to add. 
830  * \return Reference to data source if removed, or NULL if data source was not
831  *         found in index. Note the this object must still be freed.
832  */
833 AddressDataSource *addrindex_index_remove_datasource(
834         AddressIndex *addrIndex, AddressDataSource *dataSource )
835 {
836         AddressDataSource *retVal = FALSE;
837         AddressInterface *iface;
838
839         g_return_val_if_fail( addrIndex != NULL, NULL );
840         g_return_val_if_fail( dataSource != NULL, NULL );
841
842         iface = addrindex_get_interface( addrIndex, dataSource->type );
843         if( iface ) {
844                 iface->listSource = g_list_remove( iface->listSource, dataSource );
845                 addrIndex->dirtyFlag = TRUE;
846                 dataSource->interface = NULL;
847
848                 /* Remove cache from hash table */
849                 addrindex_hash_remove_cache( addrIndex, dataSource );
850
851                 retVal = dataSource;
852         }
853         return retVal;
854 }
855
856 /**
857  * Retrieve a reference to address interface for specified interface type and
858  * XML interface tag name.
859  * \param  addrIndex Address index.
860  * \param  tag       XML interface tag name to match.
861  * \param  ifType    Interface type to match.
862  * \return Reference to address index, or NULL if not found in index.
863  */
864 static AddressInterface *addrindex_tag_get_interface(
865         AddressIndex *addrIndex, gchar *tag, AddressIfType ifType )
866 {
867         AddressInterface *retVal = NULL;
868         GList *node = addrIndex->interfaceList;
869
870         while( node ) {
871                 AddressInterface *iface = node->data;
872                 node = g_list_next( node );
873                 if( tag ) {
874                         if( strcmp( iface->listTag, tag ) == 0 ) {
875                                 retVal = iface;
876                                 break;
877                         }
878                 }
879                 else {
880                         if( iface->type == ifType ) {
881                                 retVal = iface;
882                                 break;
883                         }
884                 }
885         }
886         return retVal;
887 }
888
889 /**
890  * Retrieve a reference to address interface for specified interface type and
891  * XML datasource tag name.
892  * \param  addrIndex Address index.
893  * \param  ifType    Interface type to match.
894  * \param  tag       XML datasource tag name to match.
895  * \return Reference to address index, or NULL if not found in index.
896  */
897 static AddressInterface *addrindex_tag_get_datasource(
898         AddressIndex *addrIndex, AddressIfType ifType, gchar *tag )
899 {
900         AddressInterface *retVal = NULL;
901         GList *node = addrIndex->interfaceList;
902
903         while( node ) {
904                 AddressInterface *iface = node->data;
905                 node = g_list_next( node );
906                 if( iface->type == ifType && iface->itemTag ) {
907                         if( strcmp( iface->itemTag, tag ) == 0 ) {
908                                 retVal = iface;
909                                 break;
910                         }
911                 }
912         }
913         return retVal;
914 }
915
916 /* **********************************************************************
917 * Interface XML parsing functions.
918 * ***********************************************************************
919 */
920
921 /**
922  * Write start of XML element to file.
923  * \param fp   File.
924  * \param lvl  Indentation level.
925  * \param name Element name.
926  */
927 static void addrindex_write_elem_s( FILE *fp, const gint lvl, const gchar *name ) {
928         gint i;
929         for( i = 0; i < lvl; i++ ) fputs( "  ", fp );
930         fputs( "<", fp );
931         fputs( name, fp );
932 }
933
934 /**
935  * Write end of XML element to file.
936  * \param fp   File.
937  * \param lvl  Indentation level.
938  * \param name Element name.
939  */
940 static void addrindex_write_elem_e( FILE *fp, const gint lvl, const gchar *name ) {
941         gint i;
942         for( i = 0; i < lvl; i++ ) fputs( "  ", fp );
943         fputs( "</", fp );
944         fputs( name, fp );
945         fputs( ">\n", fp );
946 }
947
948 /**
949  * Write XML attribute to file.
950  * \param fp    File.
951  * \param name  Attribute name.
952  * \param value Attribute value.
953  */
954 static void addrindex_write_attr( FILE *fp, const gchar *name, const gchar *value ) {
955         fputs( " ", fp );
956         fputs( name, fp );
957         fputs( "=\"", fp );
958         xml_file_put_escape_str( fp, value );
959         fputs( "\"", fp );
960 }
961
962 /**
963  * Return DOM fragment for current XML tag from file.
964  * \param  file XML file being processed.
965  * \return Fragment representing DOM fragment for configuration element.
966  */
967 static AddressIfFragment *addrindex_read_fragment( XMLFile *file ) {
968         AddressIfFragment *fragment;
969         AddressIfFragment *child;
970         AddressIfAttrib *nv;
971         XMLTag *xtag;
972         GList *list;
973         GList *attr;
974         gchar *name;
975         gchar *value;
976         guint prevLevel;
977         gint rc;
978
979         /* printf( "addrindex_read_fragment\n" ); */
980
981         prevLevel = file->level;
982
983         /* Get current tag name */
984         xtag = xml_get_current_tag( file );
985
986         /* Create new fragment */
987         fragment = g_new0( AddressIfFragment, 1 );
988         fragment->name = g_strdup( xtag->tag );
989         fragment->children = NULL;
990         fragment->attributes = NULL;
991
992         /* Read attributes */
993         list = NULL;
994         attr = xml_get_current_tag_attr( file );
995         while( attr ) {
996                 name = ((XMLAttr *)attr->data)->name;
997                 value = ((XMLAttr *)attr->data)->value;
998                 nv = g_new0( AddressIfAttrib, 1 );
999                 nv->name = g_strdup( name );
1000                 nv->value = g_strdup( value );
1001                 list = g_list_append( list, nv );
1002                 attr = g_list_next( attr );
1003         }
1004         fragment->attributes = list;
1005
1006         /* Now read the children */
1007         while( TRUE ) {
1008                 rc = xml_parse_next_tag( file );
1009                 if( rc != 0 ) {
1010                         /* End of file? */
1011                         break;
1012                 }
1013                 if( file->level < prevLevel ) {
1014                         /* We must be above level we start at */
1015                         break;
1016                 }
1017                 child = addrindex_read_fragment( file );
1018                 fragment->children = g_list_append( fragment->children, child );
1019         }
1020
1021         return fragment;
1022 }
1023
1024 /**
1025  * Write DOM fragment to file.
1026  * \param fp       File to write.
1027  * \param fragment DOM fragment for configuration element.
1028  * \param lvl      Indent level.
1029  */
1030 static void addrindex_write_fragment(
1031                 FILE *fp, const AddressIfFragment *fragment, const gint lvl )
1032 {
1033         GList *node;
1034
1035         if( fragment ) {
1036                 addrindex_write_elem_s( fp, lvl, fragment->name );
1037                 node = fragment->attributes;
1038                 while( node ) {
1039                         AddressIfAttrib *nv = node->data;
1040                         addrindex_write_attr( fp, nv->name, nv->value );
1041                         node = g_list_next( node );
1042                 }
1043                 if( fragment->children ) {
1044                         fputs(" >\n", fp);
1045
1046                         /* Output children */
1047                         node = fragment->children;
1048                         while( node ) {
1049                                 AddressIfFragment *child = node->data;
1050                                 addrindex_write_fragment( fp, child, 1+lvl );
1051                                 node = g_list_next( node );
1052                         }
1053
1054                         /* Output closing tag */
1055                         addrindex_write_elem_e( fp, lvl, fragment->name );
1056                 }
1057                 else {
1058                         fputs(" />\n", fp);
1059                 }
1060         }
1061 }
1062
1063 /**
1064  * Read/parse address index file, creating a data source for a regular
1065  * intrinsic XML addressbook.
1066  * \param  file Address index file.
1067  * \return Data source.
1068  */
1069 static AddressDataSource *addrindex_parse_book( XMLFile *file ) {
1070         AddressDataSource *ds;
1071         AddressBookFile *abf;
1072         GList *attr;
1073
1074         ds = addrindex_create_datasource( ADDR_IF_BOOK );
1075         abf = addrbook_create_book();
1076         attr = xml_get_current_tag_attr( file );
1077         while( attr ) {
1078                 gchar *name = ((XMLAttr *)attr->data)->name;
1079                 gchar *value = ((XMLAttr *)attr->data)->value;
1080                 if( strcmp( name, ATTAG_BOOK_NAME ) == 0 ) {
1081                         addrbook_set_name( abf, value );
1082                 }
1083                 else if( strcmp( name, ATTAG_BOOK_FILE ) == 0) {
1084                         addrbook_set_file( abf, value );
1085                 }
1086                 attr = g_list_next( attr );
1087         }
1088         ds->rawDataSource = abf;
1089         return ds;
1090 }
1091
1092 static void addrindex_write_book( FILE *fp, AddressDataSource *ds, gint lvl ) {
1093         AddressBookFile *abf = ds->rawDataSource;
1094         if( abf ) {
1095                 addrindex_write_elem_s( fp, lvl, TAG_DS_ADDRESS_BOOK );
1096                 addrindex_write_attr( fp, ATTAG_BOOK_NAME, addrbook_get_name( abf ) );
1097                 addrindex_write_attr( fp, ATTAG_BOOK_FILE, abf->fileName );
1098                 fputs( " />\n", fp );
1099         }
1100 }
1101
1102 static AddressDataSource *addrindex_parse_vcard( XMLFile *file ) {
1103         AddressDataSource *ds;
1104         VCardFile *vcf;
1105         GList *attr;
1106
1107         ds = addrindex_create_datasource( ADDR_IF_VCARD );
1108         vcf = vcard_create();
1109         attr = xml_get_current_tag_attr( file );
1110         while( attr ) {
1111                 gchar *name = ((XMLAttr *)attr->data)->name;
1112                 gchar *value = ((XMLAttr *)attr->data)->value;
1113                 if( strcmp( name, ATTAG_VCARD_NAME ) == 0 ) {
1114                         vcard_set_name( vcf, value );
1115                 }
1116                 else if( strcmp( name, ATTAG_VCARD_FILE ) == 0) {
1117                         vcard_set_file( vcf, value );
1118                 }
1119                 attr = g_list_next( attr );
1120         }
1121         ds->rawDataSource = vcf;
1122         return ds;
1123 }
1124
1125 static void addrindex_write_vcard( FILE *fp, AddressDataSource *ds, gint lvl ) {
1126         VCardFile *vcf = ds->rawDataSource;
1127         if( vcf ) {
1128                 addrindex_write_elem_s( fp, lvl, TAG_DS_VCARD );
1129                 addrindex_write_attr( fp, ATTAG_VCARD_NAME, vcard_get_name( vcf ) );
1130                 addrindex_write_attr( fp, ATTAG_VCARD_FILE, vcf->path );
1131                 fputs( " />\n", fp );
1132         }
1133 }
1134
1135 #ifdef USE_JPILOT
1136 static AddressDataSource *addrindex_parse_jpilot( XMLFile *file ) {
1137         AddressDataSource *ds;
1138         JPilotFile *jpf;
1139         GList *attr;
1140
1141         ds = addrindex_create_datasource( ADDR_IF_JPILOT );
1142         jpf = jpilot_create();
1143         attr = xml_get_current_tag_attr( file );
1144         while( attr ) {
1145                 gchar *name = ((XMLAttr *)attr->data)->name;
1146                 gchar *value = ((XMLAttr *)attr->data)->value;
1147                 if( strcmp( name, ATTAG_JPILOT_NAME ) == 0 ) {
1148                         jpilot_set_name( jpf, value );
1149                 }
1150                 else if( strcmp( name, ATTAG_JPILOT_FILE ) == 0 ) {
1151                         jpilot_set_file( jpf, value );
1152                 }
1153                 else if( strcmp( name, ATTAG_JPILOT_CUSTOM_1 ) == 0 ) {
1154                         jpilot_add_custom_label( jpf, value );
1155                 }
1156                 else if( strcmp( name, ATTAG_JPILOT_CUSTOM_2 ) == 0 ) {
1157                         jpilot_add_custom_label( jpf, value );
1158                 }
1159                 else if( strcmp( name, ATTAG_JPILOT_CUSTOM_3 ) == 0 ) {
1160                         jpilot_add_custom_label( jpf, value );
1161                 }
1162                 else if( strcmp( name, ATTAG_JPILOT_CUSTOM_4 ) == 0 ) {
1163                         jpilot_add_custom_label( jpf, value );
1164                 }
1165                 attr = g_list_next( attr );
1166         }
1167         ds->rawDataSource = jpf;
1168         return ds;
1169 }
1170
1171 static void addrindex_write_jpilot( FILE *fp,AddressDataSource *ds, gint lvl ) {
1172         JPilotFile *jpf = ds->rawDataSource;
1173         if( jpf ) {
1174                 gint ind;
1175                 GList *node;
1176                 GList *customLbl = jpilot_get_custom_labels( jpf );
1177                 addrindex_write_elem_s( fp, lvl, TAG_DS_JPILOT );
1178                 addrindex_write_attr( fp, ATTAG_JPILOT_NAME, jpilot_get_name( jpf ) );
1179                 addrindex_write_attr( fp, ATTAG_JPILOT_FILE, jpf->path );
1180                 node = customLbl;
1181                 ind = 1;
1182                 while( node ) {
1183                         gchar name[256];
1184                         g_snprintf( name, sizeof(name), "%s%d",
1185                                     ATTAG_JPILOT_CUSTOM, ind );
1186                         addrindex_write_attr( fp, name, node->data );
1187                         ind++;
1188                         node = g_list_next( node );
1189                 }
1190                 fputs( " />\n", fp );
1191         }
1192 }
1193
1194 #else
1195 /*
1196  * Just read/write DOM fragments (preserve data found in file).
1197  */
1198 static AddressDataSource *addrindex_parse_jpilot( XMLFile *file ) {
1199         AddressDataSource *ds;
1200
1201         ds = addrindex_create_datasource( ADDR_IF_JPILOT );
1202         ds->rawDataSource = addrindex_read_fragment( file );
1203         return ds;
1204 }
1205
1206 static void addrindex_write_jpilot( FILE *fp, AddressDataSource *ds, gint lvl ) {
1207         AddressIfFragment *fragment = ds->rawDataSource;
1208         if( fragment ) {
1209                 addrindex_write_fragment( fp, fragment, lvl );
1210         }
1211 }
1212 #endif
1213
1214 #ifdef USE_LDAP
1215 /**
1216  * Parse LDAP criteria attribute data from XML file.
1217  * \param file Index file.
1218  * \param ctl  LDAP control object to populate.
1219  */
1220 static void addrindex_parse_ldap_attrlist( XMLFile *file, LdapControl *ctl ) {
1221         guint prevLevel;
1222         XMLTag *xtag;
1223         XMLTag *xtagPrev;
1224         gint rc;
1225         GList *attr;
1226         GList *list;
1227         GList *node;
1228
1229         if( file == NULL ) {
1230                 return;
1231         }
1232
1233         list = NULL;
1234         prevLevel = file->level;
1235         xtagPrev = xml_get_current_tag( file );
1236         while( TRUE ) {
1237                 rc = xml_parse_next_tag( file );
1238                 if( rc != 0 ) {
1239                         /* Terminate prematurely */
1240                         mgu_free_dlist( list );
1241                         list = NULL;
1242                         return;
1243                 }
1244                 if( file->level < prevLevel ) {
1245                         /* We must be above level we start at */
1246                         break;
1247                 }
1248
1249                 /* Get a tag (element) */
1250                 xtag = xml_get_current_tag( file );
1251                 if( strcmp( xtag->tag, ELTAG_LDAP_ATTR_SRCH ) == 0 ) {
1252                         /* LDAP criteria attribute */
1253                         attr = xml_get_current_tag_attr( file );
1254                         while( attr ) {
1255                                 gchar *name = ((XMLAttr *)attr->data)->name;
1256                                 gchar *value = ((XMLAttr *)attr->data)->value;
1257                                 if( strcmp( name, ATTAG_LDAP_ATTR_NAME ) == 0 ) {
1258                                         if( value && strlen( value ) > 0 ) {
1259                                                 list = g_list_append(
1260                                                         list, g_strdup( value ) );
1261                                         }
1262                                 }
1263                                 attr = g_list_next( attr );
1264                         }
1265                 }
1266                 else {
1267                         if( xtag != xtagPrev ) {
1268                                 /* Found a new tag */
1269                                 break;
1270                         }
1271                 }
1272                 xtag = xtagPrev;
1273         }
1274
1275         /* Build list of search attributes */
1276         ldapctl_criteria_list_clear( ctl );
1277         node = list;
1278         while( node ) {
1279                 ldapctl_criteria_list_add( ctl, node->data );
1280                 g_free( node->data );
1281                 node->data = NULL;
1282                 node = g_list_next( node );
1283         }
1284         g_list_free( list );
1285         list = NULL;
1286
1287 }
1288
1289 void ldapsvr_set_control( LdapServer *server, LdapControl *ctl );
1290 /**
1291  * Parse LDAP control data from XML file.
1292  * \param  file Index file.
1293  * \return Initialized data soruce object.
1294  */
1295 static AddressDataSource *addrindex_parse_ldap( XMLFile *file ) {
1296         AddressDataSource *ds;
1297         LdapServer *server;
1298         LdapControl *ctl;
1299         GList *attr;
1300         gchar *serverName = NULL;
1301         gchar *criteria = NULL;
1302         gboolean bDynSearch;
1303         gboolean bTLS, bSSL;
1304         gint iMatch;
1305
1306         /* printf( "addrindex_parse_ldap\n" ); */
1307         /* Set up some defaults */
1308         bDynSearch = FALSE;
1309         bTLS = FALSE;
1310         bSSL = FALSE;
1311         iMatch = LDAPCTL_MATCH_BEGINWITH;
1312
1313         ds = addrindex_create_datasource( ADDR_IF_LDAP );
1314         ctl = ldapctl_create();
1315         attr = xml_get_current_tag_attr( file );
1316         while( attr ) {
1317                 gchar *name = ((XMLAttr *)attr->data)->name;
1318                 gchar *value = ((XMLAttr *)attr->data)->value;
1319                 gint ivalue = atoi( value );
1320
1321                 if( strcmp( name, ATTAG_LDAP_NAME ) == 0 ) {
1322                         g_free( serverName );
1323                         serverName = g_strdup( value );
1324                 }
1325                 else if( strcmp( name, ATTAG_LDAP_HOST ) == 0 ) {
1326                         ldapctl_set_host( ctl, value );
1327                 }
1328                 else if( strcmp( name, ATTAG_LDAP_PORT ) == 0 ) {
1329                         ldapctl_set_port( ctl, ivalue );
1330                 }
1331                 else if( strcmp( name, ATTAG_LDAP_BASE_DN ) == 0 ) {
1332                         ldapctl_set_base_dn( ctl, value );
1333                 }
1334                 else if( strcmp( name, ATTAG_LDAP_BIND_DN ) == 0 ) {
1335                         ldapctl_set_bind_dn( ctl, value );
1336                 }
1337                 else if( strcmp( name, ATTAG_LDAP_BIND_PASS ) == 0 ) {
1338                         ldapctl_set_bind_password( ctl, value );
1339                 }
1340                 else if( strcmp( name, ATTAG_LDAP_CRITERIA ) == 0 ) {
1341                         g_free( criteria );
1342                         criteria = g_strdup( value );
1343                 }
1344                 else if( strcmp( name, ATTAG_LDAP_MAX_ENTRY ) == 0 ) {
1345                         ldapctl_set_max_entries( ctl, ivalue );
1346                 }
1347                 else if( strcmp( name, ATTAG_LDAP_TIMEOUT ) == 0 ) {
1348                         ldapctl_set_timeout( ctl, ivalue );
1349                 }
1350                 else if( strcmp( name, ATTAG_LDAP_MAX_AGE ) == 0 ) {
1351                         ldapctl_set_max_query_age( ctl, ivalue );
1352                 }
1353                 else if( strcmp( name, ATTAG_LDAP_DYN_SEARCH ) == 0 ) {
1354                         bDynSearch = FALSE;
1355                         if( strcmp( value, ATVAL_BOOLEAN_YES ) == 0 ) {
1356                                 bDynSearch = TRUE;
1357                         }
1358                 }
1359                 else if( strcmp( name, ATTAG_LDAP_MATCH_OPT ) == 0 ) {
1360                         iMatch = LDAPCTL_MATCH_BEGINWITH;
1361                         if( strcmp( value, ATVAL_LDAP_MATCH_CONTAINS ) == 0 ) {
1362                                 iMatch = LDAPCTL_MATCH_CONTAINS;
1363                         }
1364                 }
1365                 else if( strcmp( name, ATTAG_LDAP_ENABLE_TLS ) == 0 ) {
1366                         bTLS = FALSE;
1367                         if( strcmp( value, ATVAL_BOOLEAN_YES ) == 0 ) {
1368                                 bTLS = TRUE;
1369                         }
1370                 }
1371                 else if( strcmp( name, ATTAG_LDAP_ENABLE_SSL ) == 0 ) {
1372                         bSSL = FALSE;
1373                         if( strcmp( value, ATVAL_BOOLEAN_YES ) == 0 ) {
1374                                 bSSL = TRUE;
1375                         }
1376                 }
1377                 attr = g_list_next( attr );
1378         }
1379
1380         server = ldapsvr_create_noctl();
1381         ldapsvr_set_name( server, serverName );
1382         ldapsvr_set_search_flag( server, bDynSearch );
1383         ldapctl_set_matching_option( ctl, iMatch );
1384 #ifdef USE_LDAP_TLS
1385         ldapctl_set_tls( ctl, bTLS );
1386         ldapctl_set_ssl( ctl, bSSL );
1387 #endif
1388         g_free( serverName );
1389         ldapsvr_set_control( server, ctl );
1390         ds->rawDataSource = server;
1391
1392         addrindex_parse_ldap_attrlist( file, ctl );
1393         /*
1394          * If criteria have been specified and no attributes were listed, then
1395          * convert old style criteria into an attribute list. Any criteria will
1396          * be dropped when saving data.
1397          */
1398         if( criteria ) {
1399                 if( ! ldapctl_get_criteria_list( ctl ) ) {
1400                         ldapctl_parse_ldap_search( ctl, criteria );
1401                 }
1402                 g_free( criteria );
1403         }
1404         /* ldapsvr_print_data( server, stdout ); */
1405
1406         return ds;
1407 }
1408
1409 static void addrindex_write_ldap( FILE *fp, AddressDataSource *ds, gint lvl ) {
1410         LdapServer *server = ds->rawDataSource;
1411         LdapControl *ctl = NULL;
1412         GList *node;
1413         gchar value[256];
1414
1415         if( server ) {
1416                 ctl = server->control;
1417         }
1418         if( ctl == NULL ) return;
1419
1420         /* Output start element with attributes */
1421         addrindex_write_elem_s( fp, lvl, TAG_DS_LDAP );
1422         addrindex_write_attr( fp, ATTAG_LDAP_NAME, ldapsvr_get_name( server ) );
1423         addrindex_write_attr( fp, ATTAG_LDAP_HOST, ctl->hostName );
1424
1425         sprintf( value, "%d", ctl->port );      
1426         addrindex_write_attr( fp, ATTAG_LDAP_PORT, value );
1427
1428         addrindex_write_attr( fp, ATTAG_LDAP_BASE_DN, ctl->baseDN );
1429         addrindex_write_attr( fp, ATTAG_LDAP_BIND_DN, ctl->bindDN );
1430         addrindex_write_attr( fp, ATTAG_LDAP_BIND_PASS, ctl->bindPass );
1431
1432         sprintf( value, "%d", ctl->maxEntries );
1433         addrindex_write_attr( fp, ATTAG_LDAP_MAX_ENTRY, value );
1434         sprintf( value, "%d", ctl->timeOut );
1435         addrindex_write_attr( fp, ATTAG_LDAP_TIMEOUT, value );
1436         sprintf( value, "%d", ctl->maxQueryAge );
1437         addrindex_write_attr( fp, ATTAG_LDAP_MAX_AGE, value );
1438
1439         addrindex_write_attr( fp, ATTAG_LDAP_DYN_SEARCH,
1440                         server->searchFlag ?
1441                         ATVAL_BOOLEAN_YES : ATVAL_BOOLEAN_NO );
1442
1443         addrindex_write_attr( fp, ATTAG_LDAP_MATCH_OPT,
1444                 ( ctl->matchingOption == LDAPCTL_MATCH_CONTAINS ) ?
1445                 ATVAL_LDAP_MATCH_CONTAINS : ATVAL_LDAP_MATCH_BEGIN );
1446
1447         addrindex_write_attr( fp, ATTAG_LDAP_ENABLE_TLS,
1448                         ctl->enableTLS ?
1449                         ATVAL_BOOLEAN_YES : ATVAL_BOOLEAN_NO );
1450         addrindex_write_attr( fp, ATTAG_LDAP_ENABLE_SSL,
1451                         ctl->enableSSL ?
1452                         ATVAL_BOOLEAN_YES : ATVAL_BOOLEAN_NO );
1453
1454         fputs(" >\n", fp);
1455
1456         /* Output attributes */
1457         node = ldapctl_get_criteria_list( ctl );
1458         while( node ) {
1459                 addrindex_write_elem_s( fp, 1+lvl, ELTAG_LDAP_ATTR_SRCH );
1460                 addrindex_write_attr( fp, ATTAG_LDAP_ATTR_NAME, node->data );
1461                 fputs(" />\n", fp);
1462                 node = g_list_next( node );
1463         }
1464
1465         /* End of element */    
1466         addrindex_write_elem_e( fp, lvl, TAG_DS_LDAP );
1467 }
1468
1469 #else
1470 /*
1471  * Just read/write DOM fragments (preserve data found in file).
1472  */
1473 static AddressDataSource *addrindex_parse_ldap( XMLFile *file ) {
1474         AddressDataSource *ds;
1475
1476         ds = addrindex_create_datasource( ADDR_IF_LDAP );
1477         ds->rawDataSource = addrindex_read_fragment( file );
1478         return ds;
1479 }
1480
1481 static void addrindex_write_ldap( FILE *fp, AddressDataSource *ds, gint lvl ) {
1482         AddressIfFragment *fragment = ds->rawDataSource;
1483         if( fragment ) {
1484                 addrindex_write_fragment( fp, fragment, lvl );
1485         }
1486 }
1487 #endif
1488
1489 /* **********************************************************************
1490 * Address index I/O functions.
1491 * ***********************************************************************
1492 */
1493 /**
1494  * Read address index file, creating appropriate data sources for each address
1495  * index file entry.
1496  *
1497  * \param  addrIndex Address index.
1498  * \param  file Address index file.
1499  */
1500 static void addrindex_read_index( AddressIndex *addrIndex, XMLFile *file ) {
1501         guint prev_level;
1502         XMLTag *xtag;
1503         AddressInterface *iface = NULL, *dsIFace = NULL;
1504         AddressDataSource *ds;
1505         gint rc;
1506
1507         addrIndex->loadedFlag = FALSE;
1508         for (;;) {
1509                 prev_level = file->level;
1510                 rc = xml_parse_next_tag( file );
1511                 if( file->level == 0 ) return;
1512
1513                 xtag = xml_get_current_tag( file );
1514
1515                 iface = addrindex_tag_get_interface( addrIndex, xtag->tag, ADDR_IF_NONE );
1516                 if( iface ) {
1517                         addrIndex->lastType = iface->type;
1518                         if( iface->legacyFlag ) addrIndex->needsConversion = TRUE;
1519                 }
1520                 else {
1521                         dsIFace = addrindex_tag_get_datasource(
1522                                         addrIndex, addrIndex->lastType, xtag->tag );
1523                         if( dsIFace ) {
1524                                 /* Add data source to list */
1525                                 ds = NULL;
1526                                 if( addrIndex->lastType == ADDR_IF_BOOK ) {
1527                                         ds = addrindex_parse_book( file );
1528                                         if( ds->rawDataSource ) {
1529                                                 addrbook_set_path( ds->rawDataSource,
1530                                                         addrIndex->filePath );
1531                                         }
1532                                 }
1533                                 else if( addrIndex->lastType == ADDR_IF_VCARD ) {
1534                                         ds = addrindex_parse_vcard( file );
1535                                 }
1536                                 else if( addrIndex->lastType == ADDR_IF_JPILOT ) {
1537                                         ds = addrindex_parse_jpilot( file );
1538                                 }
1539                                 else if( addrIndex->lastType == ADDR_IF_LDAP ) {
1540                                         ds = addrindex_parse_ldap( file );
1541                                 }
1542                                 if( ds ) {
1543                                         ds->interface = dsIFace;
1544                                         addrindex_hash_add_cache( addrIndex, ds );
1545                                         dsIFace->listSource =
1546                                                 g_list_append( dsIFace->listSource, ds );
1547                                 }
1548                         }
1549                 }
1550         }
1551 }
1552
1553 /*
1554  * Search order sorting comparison function for building search order list.
1555  */
1556 static gint addrindex_search_order_compare( gconstpointer ptrA, gconstpointer ptrB ) {
1557         AddressInterface *ifaceA = ( AddressInterface * ) ptrA;
1558         AddressInterface *ifaceB = ( AddressInterface * ) ptrB;
1559
1560         return ifaceA->searchOrder - ifaceB->searchOrder;
1561 }
1562
1563 /**
1564  * Build list of data sources to process.
1565  * \param addrIndex Address index object.
1566  */
1567 static void addrindex_build_search_order( AddressIndex *addrIndex ) {
1568         GList *nodeIf;
1569
1570         /* Clear existing list */
1571         g_list_free( addrIndex->searchOrder );
1572         addrIndex->searchOrder = NULL;
1573
1574         /* Build new list */
1575         nodeIf = addrIndex->interfaceList;
1576         while( nodeIf ) {
1577                 AddressInterface *iface = nodeIf->data;
1578                 if( iface->useInterface ) {
1579                         if( iface->searchOrder > 0 ) {
1580                                 /* Add to search order list */
1581                                 addrIndex->searchOrder = g_list_insert_sorted(
1582                                         addrIndex->searchOrder, iface,
1583                                         addrindex_search_order_compare );
1584                         }
1585                 }
1586                 nodeIf = g_list_next( nodeIf );
1587         }
1588 }
1589
1590 static gint addrindex_read_file( AddressIndex *addrIndex ) {
1591         XMLFile *file = NULL;
1592         gchar *fileSpec = NULL;
1593
1594         g_return_val_if_fail( addrIndex != NULL, -1 );
1595
1596         fileSpec = g_strconcat( addrIndex->filePath, G_DIR_SEPARATOR_S, addrIndex->fileName, NULL );
1597         addrIndex->retVal = MGU_NO_FILE;
1598         file = xml_open_file( fileSpec );
1599         g_free( fileSpec );
1600
1601         if( file == NULL ) {
1602                 /*
1603                 fprintf( stdout, " file '%s' does not exist.\n", addrIndex->fileName );
1604                 */
1605                 return addrIndex->retVal;
1606         }
1607
1608         addrIndex->retVal = MGU_BAD_FORMAT;
1609         if( xml_get_dtd( file ) == 0 ) {
1610                 if( xml_parse_next_tag( file ) == 0 ) {
1611                         if( xml_compare_tag( file, TAG_ADDRESS_INDEX ) ) {
1612                                 addrindex_read_index( addrIndex, file );
1613                                 addrIndex->retVal = MGU_SUCCESS;
1614                         }
1615                 }
1616         }
1617         xml_close_file( file );
1618
1619         addrindex_build_search_order( addrIndex );
1620
1621         return addrIndex->retVal;
1622 }
1623
1624 static void addrindex_write_index( AddressIndex *addrIndex, FILE *fp ) {
1625         GList *nodeIF, *nodeDS;
1626         gint lvlList = 1;
1627         gint lvlItem = 1 + lvlList;
1628
1629         nodeIF = addrIndex->interfaceList;
1630         while( nodeIF ) {
1631                 AddressInterface *iface = nodeIF->data;
1632                 if( ! iface->legacyFlag ) {
1633                         nodeDS = iface->listSource;
1634                         addrindex_write_elem_s( fp, lvlList, iface->listTag );
1635                         fputs( ">\n", fp );
1636                         while( nodeDS ) {
1637                                 AddressDataSource *ds = nodeDS->data;
1638                                 if( ds ) {
1639                                         if( iface->type == ADDR_IF_BOOK ) {
1640                                                 addrindex_write_book( fp, ds, lvlItem );
1641                                         }
1642                                         if( iface->type == ADDR_IF_VCARD ) {
1643                                                 addrindex_write_vcard( fp, ds, lvlItem );
1644                                         }
1645                                         if( iface->type == ADDR_IF_JPILOT ) {
1646                                                 addrindex_write_jpilot( fp, ds, lvlItem );
1647                                         }
1648                                         if( iface->type == ADDR_IF_LDAP ) {
1649                                                 addrindex_write_ldap( fp, ds, lvlItem );
1650                                         }
1651                                 }
1652                                 nodeDS = g_list_next( nodeDS );
1653                         }
1654                         addrindex_write_elem_e( fp, lvlList, iface->listTag );
1655                 }
1656                 nodeIF = g_list_next( nodeIF );
1657         }
1658 }
1659
1660 /*
1661 * Write data to specified file.
1662 * Enter: addrIndex Address index object.
1663 *        newFile   New file name.
1664 * return: Status code, from addrIndex->retVal.
1665 * Note: File will be created in directory specified by addrIndex.
1666 */
1667 static gint addrindex_write_to( AddressIndex *addrIndex, const gchar *newFile ) {
1668         FILE *fp;
1669         gchar *fileSpec;
1670 #ifndef DEV_STANDALONE
1671         PrefFile *pfile;
1672 #endif
1673
1674         g_return_val_if_fail( addrIndex != NULL, -1 );
1675
1676         fileSpec = g_strconcat( addrIndex->filePath, G_DIR_SEPARATOR_S, newFile, NULL );
1677         addrIndex->retVal = MGU_OPEN_FILE;
1678 #ifdef DEV_STANDALONE
1679         fp = g_fopen( fileSpec, "wb" );
1680         g_free( fileSpec );
1681         if( fp ) {
1682                 fputs( "<?xml version=\"1.0\" ?>\n", fp );
1683 #else
1684         pfile = prefs_write_open( fileSpec );
1685         g_free( fileSpec );
1686         if( pfile ) {
1687                 fp = pfile->fp;
1688                 fprintf( fp, "<?xml version=\"1.0\" encoding=\"%s\" ?>\n", CS_INTERNAL );
1689 #endif
1690                 addrindex_write_elem_s( fp, 0, TAG_ADDRESS_INDEX );
1691                 fputs( ">\n", fp );
1692
1693                 addrindex_write_index( addrIndex, fp );
1694                 addrindex_write_elem_e( fp, 0, TAG_ADDRESS_INDEX );
1695
1696                 addrIndex->retVal = MGU_SUCCESS;
1697 #ifdef DEV_STANDALONE
1698                 fclose( fp );
1699 #else
1700                 if( prefs_file_close( pfile ) < 0 ) {
1701                         addrIndex->retVal = MGU_ERROR_WRITE;
1702                 }
1703 #endif
1704         }
1705
1706         fileSpec = NULL;
1707         return addrIndex->retVal;
1708 }
1709
1710 /*
1711 * Save address index data to original file.
1712 * return: Status code, from addrIndex->retVal.
1713 */
1714 gint addrindex_save_data( AddressIndex *addrIndex ) {
1715         g_return_val_if_fail( addrIndex != NULL, -1 );
1716
1717         addrIndex->retVal = MGU_NO_FILE;
1718         if( addrIndex->fileName == NULL || *addrIndex->fileName == '\0' ) return addrIndex->retVal;
1719         if( addrIndex->filePath == NULL || *addrIndex->filePath == '\0' ) return addrIndex->retVal;
1720
1721         addrindex_write_to( addrIndex, addrIndex->fileName );
1722         if( addrIndex->retVal == MGU_SUCCESS ) {
1723                 addrIndex->dirtyFlag = FALSE;
1724         }
1725         return addrIndex->retVal;
1726 }
1727
1728 /*
1729 * Save all address book files which may have changed.
1730 * Return: Status code, set if there was a problem saving data.
1731 */
1732 gint addrindex_save_all_books( AddressIndex *addrIndex ) {
1733         gint retVal = MGU_SUCCESS;
1734         GList *nodeIf, *nodeDS;
1735
1736         nodeIf = addrIndex->interfaceList;
1737         while( nodeIf ) {
1738                 AddressInterface *iface = nodeIf->data;
1739                 if( iface->type == ADDR_IF_BOOK ) {
1740                         nodeDS = iface->listSource;
1741                         while( nodeDS ) {
1742                                 AddressDataSource *ds = nodeDS->data;
1743                                 AddressBookFile *abf = ds->rawDataSource;
1744                                 if( addrbook_get_dirty( abf ) ) {
1745                                         if( addrbook_get_read_flag( abf ) ) {
1746                                                 addrbook_save_data( abf );
1747                                                 if( abf->retVal != MGU_SUCCESS ) {
1748                                                         retVal = abf->retVal;
1749                                                 }
1750                                         }
1751                                 }
1752                                 nodeDS = g_list_next( nodeDS );
1753                         }
1754                         break;
1755                 }
1756                 nodeIf = g_list_next( nodeIf );
1757         }
1758         return retVal;
1759 }
1760
1761
1762 /* **********************************************************************
1763 * Address book conversion to new format.
1764 * ***********************************************************************
1765 */
1766
1767 #define ELTAG_IF_OLD_FOLDER   "folder"
1768 #define ELTAG_IF_OLD_GROUP    "group"
1769 #define ELTAG_IF_OLD_ITEM     "item"
1770 #define ELTAG_IF_OLD_NAME     "name"
1771 #define ELTAG_IF_OLD_ADDRESS  "address"
1772 #define ELTAG_IF_OLD_REMARKS  "remarks"
1773 #define ATTAG_IF_OLD_NAME     "name"
1774
1775 #define TEMPNODE_ROOT         0
1776 #define TEMPNODE_FOLDER       1
1777 #define TEMPNODE_GROUP        2
1778 #define TEMPNODE_ADDRESS      3
1779
1780 typedef struct _AddressCvt_Node AddressCvtNode;
1781 struct _AddressCvt_Node {
1782         gint  type;
1783         gchar *name;
1784         gchar *address;
1785         gchar *remarks;
1786         GList *list;
1787 };
1788
1789 /*
1790 * Parse current address item.
1791 */
1792 static AddressCvtNode *addrindex_parse_item( XMLFile *file ) {
1793         gchar *element;
1794         guint level;
1795         AddressCvtNode *nn;
1796
1797         nn = g_new0( AddressCvtNode, 1 );
1798         nn->type = TEMPNODE_ADDRESS;
1799         nn->list = NULL;
1800
1801         level = file->level;
1802
1803         for (;;) {
1804                 xml_parse_next_tag(file);
1805                 if (file->level < level) return nn;
1806
1807                 element = xml_get_element( file );
1808                 if( xml_compare_tag( file, ELTAG_IF_OLD_NAME ) ) {
1809                         nn->name = g_strdup( element );
1810                 }
1811                 if( xml_compare_tag( file, ELTAG_IF_OLD_ADDRESS ) ) {
1812                         nn->address = g_strdup( element );
1813                 }
1814                 if( xml_compare_tag( file, ELTAG_IF_OLD_REMARKS ) ) {
1815                         nn->remarks = g_strdup( element );
1816                 }
1817                 g_free(element);
1818                 xml_parse_next_tag(file);
1819         }
1820 }
1821
1822 /*
1823 * Create a temporary node below specified node.
1824 */
1825 static AddressCvtNode *addrindex_add_object( AddressCvtNode *node, gint type, gchar *name, gchar *addr, char *rem ) {
1826         AddressCvtNode *nn;
1827         nn = g_new0( AddressCvtNode, 1 );
1828         nn->type = type;
1829         nn->name = g_strdup( name );
1830         nn->remarks = g_strdup( rem );
1831         node->list = g_list_append( node->list, nn );
1832         return nn;
1833 }
1834
1835 /*
1836 * Process current temporary node.
1837 */
1838 static void addrindex_add_obj( XMLFile *file, AddressCvtNode *node ) {
1839         GList *attr;
1840         guint prev_level;
1841         AddressCvtNode *newNode = NULL;
1842         gchar *name;
1843         gchar *value;
1844
1845         for (;;) {
1846                 prev_level = file->level;
1847                 xml_parse_next_tag( file );
1848                 if (file->level < prev_level) return;
1849                 name = NULL;
1850                 value = NULL;
1851
1852                 if( xml_compare_tag( file, ELTAG_IF_OLD_GROUP ) ) {
1853                         attr = xml_get_current_tag_attr(file);
1854                         if (attr) {
1855                                 name = ((XMLAttr *)attr->data)->name;
1856                                 if( strcmp( name, ATTAG_IF_OLD_NAME ) == 0 ) {
1857                                         value = ((XMLAttr *)attr->data)->value;
1858                                 }
1859                         }
1860                         newNode = addrindex_add_object( node, TEMPNODE_GROUP, value, "", "" );
1861                         addrindex_add_obj( file, newNode );
1862
1863                 }
1864                 else if( xml_compare_tag( file, ELTAG_IF_OLD_FOLDER ) ) {
1865                         attr = xml_get_current_tag_attr(file);
1866                         if (attr) {
1867                                 name = ((XMLAttr *)attr->data)->name;
1868                                 if( strcmp( name, ATTAG_IF_OLD_NAME ) == 0 ) {
1869                                         value = ((XMLAttr *)attr->data)->value;
1870                                 }
1871                         }
1872                         newNode = addrindex_add_object( node, TEMPNODE_FOLDER, value, "", "" );
1873                         addrindex_add_obj( file, newNode );
1874                 }
1875                 else if( xml_compare_tag( file, ELTAG_IF_OLD_ITEM ) ) {
1876                         newNode = addrindex_parse_item( file );
1877                         node->list = g_list_append( node->list, newNode );
1878                 }
1879                 else {
1880                         /* printf( "invalid: !!! \n" ); */
1881                         attr = xml_get_current_tag_attr( file );
1882                 }
1883         }
1884 }
1885
1886 /*
1887 * Consume all nodes below current tag.
1888 */
1889 static void addrindex_consume_tree( XMLFile *file ) {
1890         guint prev_level;
1891         gchar *element;
1892         GList *attr;
1893         XMLTag *xtag;
1894
1895         for (;;) {
1896                 prev_level = file->level;
1897                 xml_parse_next_tag( file );
1898                 if (file->level < prev_level) return;
1899
1900                 xtag = xml_get_current_tag( file );
1901                 /* printf( "tag : %s\n", xtag->tag ); */
1902                 element = xml_get_element( file );
1903                 attr = xml_get_current_tag_attr( file );
1904                 /* show_attribs( attr ); */
1905                 /* printf( "\ttag  value : %s :\n", element ); */
1906                 addrindex_consume_tree( file );
1907         }
1908 }
1909
1910 /*
1911 * Print temporary tree.
1912 */
1913 static void addrindex_print_node( AddressCvtNode *node, FILE *stream  ) {
1914         GList *list;
1915
1916         fprintf( stream, "Node:\ttype :%d:\n", node->type );
1917         fprintf( stream, "\tname :%s:\n", node->name );
1918         fprintf( stream, "\taddr :%s:\n", node->address );
1919         fprintf( stream, "\trems :%s:\n", node->remarks );
1920         if( node->list ) {
1921                 fprintf( stream, "\t--list----\n" );
1922         }
1923         list = node->list;
1924         while( list ) {
1925                 AddressCvtNode *lNode = list->data;
1926                 list = g_list_next( list );
1927                 addrindex_print_node( lNode, stream );
1928         }
1929         fprintf( stream, "\t==list-%d==\n", node->type );
1930 }
1931
1932 /*
1933 * Free up temporary tree.
1934 */
1935 static void addrindex_free_node( AddressCvtNode *node ) {
1936         GList *list = node->list;
1937
1938         while( list ) {
1939                 AddressCvtNode *lNode = list->data;
1940                 list = g_list_next( list );
1941                 addrindex_free_node( lNode );
1942         }
1943         node->type = TEMPNODE_ROOT;
1944         g_free( node->name );
1945         g_free( node->address );
1946         g_free( node->remarks );
1947         g_list_free( node->list );
1948         g_free( node );
1949 }
1950
1951 /*
1952 * Process address book for specified node.
1953 */
1954 static void addrindex_process_node(
1955                 AddressBookFile *abf, AddressCvtNode *node, ItemFolder *parent,
1956                 ItemGroup *parentGrp, ItemFolder *folderGrp )
1957 {
1958         GList *list;
1959         ItemFolder *itemFolder = NULL;
1960         ItemGroup *itemGParent = parentGrp;
1961         ItemFolder *itemGFolder = folderGrp;
1962         AddressCache *cache = abf->addressCache;
1963
1964         if( node->type == TEMPNODE_ROOT ) {
1965                 itemFolder = parent;
1966         }
1967         else if( node->type == TEMPNODE_FOLDER ) {
1968                 itemFolder = addritem_create_item_folder();
1969                 addritem_folder_set_name( itemFolder, node->name );
1970                 addrcache_id_folder( cache, itemFolder );
1971                 addrcache_folder_add_folder( cache, parent, itemFolder );
1972                 itemGFolder = NULL;
1973         }
1974         else if( node->type == TEMPNODE_GROUP ) {
1975                 ItemGroup *itemGroup;
1976                 gchar *fName;
1977
1978                 /* Create a folder for group */
1979                 fName = g_strdup_printf( "Cvt - %s", node->name );
1980                 itemGFolder = addritem_create_item_folder();
1981                 addritem_folder_set_name( itemGFolder, fName );
1982                 addrcache_id_folder( cache, itemGFolder );
1983                 addrcache_folder_add_folder( cache, parent, itemGFolder );
1984                 g_free( fName );
1985
1986                 /* Add group into folder */
1987                 itemGroup = addritem_create_item_group();
1988                 addritem_group_set_name( itemGroup, node->name );
1989                 addrcache_id_group( cache, itemGroup );
1990                 addrcache_folder_add_group( cache, itemGFolder, itemGroup );
1991                 itemGParent = itemGroup;
1992         }
1993         else if( node->type == TEMPNODE_ADDRESS ) {
1994                 ItemPerson *itemPerson;
1995                 ItemEMail *itemEMail;
1996
1997                 /* Create person and email objects */
1998                 itemPerson = addritem_create_item_person();
1999                 addritem_person_set_common_name( itemPerson, node->name );
2000                 addrcache_id_person( cache, itemPerson );
2001                 itemEMail = addritem_create_item_email();
2002                 addritem_email_set_address( itemEMail, node->address );
2003                 addritem_email_set_remarks( itemEMail, node->remarks );
2004                 addrcache_id_email( cache, itemEMail );
2005                 addrcache_person_add_email( cache, itemPerson, itemEMail );
2006
2007                 /* Add person into appropriate folder */
2008                 if( itemGFolder ) {
2009                         addrcache_folder_add_person( cache, itemGFolder, itemPerson );
2010                 }
2011                 else {
2012                         addrcache_folder_add_person( cache, parent, itemPerson );
2013                 }
2014
2015                 /* Add email address only into group */
2016                 if( parentGrp ) {
2017                         addrcache_group_add_email( cache, parentGrp, itemEMail );
2018                 }
2019         }
2020
2021         list = node->list;
2022         while( list ) {
2023                 AddressCvtNode *lNode = list->data;
2024                 list = g_list_next( list );
2025                 addrindex_process_node( abf, lNode, itemFolder, itemGParent, itemGFolder );
2026         }
2027 }
2028
2029 /*
2030 * Process address book to specified file number.
2031 */
2032 static gboolean addrindex_process_book( AddressIndex *addrIndex, XMLFile *file, gchar *displayName ) {
2033         gboolean retVal = FALSE;
2034         AddressBookFile *abf = NULL;
2035         AddressCvtNode *rootNode = NULL;
2036         gchar *newFile = NULL;
2037         GList *fileList = NULL;
2038         gint fileNum  = 0;
2039
2040         /* Setup root node */
2041         rootNode = g_new0( AddressCvtNode, 1 );
2042         rootNode->type = TEMPNODE_ROOT;
2043         rootNode->name = g_strdup( "root" );
2044         rootNode->list = NULL;
2045         addrindex_add_obj( file, rootNode );
2046         /* addrindex_print_node( rootNode, stdout ); */
2047
2048         /* Create new address book */
2049         abf = addrbook_create_book();
2050         addrbook_set_name( abf, displayName );
2051         addrbook_set_path( abf, addrIndex->filePath );
2052
2053         /* Determine next available file number */
2054         fileList = addrbook_get_bookfile_list( abf );
2055         if( fileList ) {
2056                 fileNum = 1 + abf->maxValue;
2057         }
2058         g_list_free( fileList );
2059         fileList = NULL;
2060
2061         newFile = addrbook_gen_new_file_name( fileNum );
2062         if( newFile ) {
2063                 addrbook_set_file( abf, newFile );
2064         }
2065
2066         addrindex_process_node( abf, rootNode, abf->addressCache->rootFolder, NULL, NULL );
2067
2068         /* addrbook_dump_book( abf, stdout ); */
2069         addrbook_save_data( abf );
2070         addrIndex->retVal = abf->retVal;
2071         if( abf->retVal == MGU_SUCCESS ) retVal = TRUE;
2072
2073         addrbook_free_book( abf );
2074         abf = NULL;
2075         addrindex_free_node( rootNode );
2076         rootNode = NULL;
2077
2078         /* Create entries in address index */
2079         if( retVal ) {
2080                 abf = addrbook_create_book();
2081                 addrbook_set_name( abf, displayName );
2082                 addrbook_set_path( abf, addrIndex->filePath );
2083                 addrbook_set_file( abf, newFile );
2084                 addrindex_index_add_datasource( addrIndex, ADDR_IF_BOOK, abf );
2085         }
2086
2087         return retVal;
2088 }
2089
2090 /*
2091 * Process tree converting data.
2092 */
2093 static void addrindex_convert_tree( AddressIndex *addrIndex, XMLFile *file ) {
2094         guint prev_level;
2095         gchar *element;
2096         GList *attr;
2097         XMLTag *xtag;
2098
2099         /* Process file */
2100         for (;;) {
2101                 prev_level = file->level;
2102                 xml_parse_next_tag( file );
2103                 if (file->level < prev_level) return;
2104
2105                 xtag = xml_get_current_tag( file );
2106                 /* printf( "tag : %d : %s\n", prev_level, xtag->tag ); */
2107                 if( strcmp( xtag->tag, TAG_IF_OLD_COMMON ) == 0 ) {
2108                         if( addrindex_process_book( addrIndex, file, DISP_OLD_COMMON ) ) {
2109                                 addrIndex->needsConversion = FALSE;
2110                                 addrIndex->wasConverted = TRUE;
2111                                 continue;
2112                         }
2113                         return;
2114                 }
2115                 if( strcmp( xtag->tag, TAG_IF_OLD_PERSONAL ) == 0 ) {
2116                         if( addrindex_process_book( addrIndex, file, DISP_OLD_PERSONAL ) ) {
2117                                 addrIndex->needsConversion = FALSE;
2118                                 addrIndex->wasConverted = TRUE;
2119                                 continue;
2120                         }
2121                         return;
2122                 }
2123                 element = xml_get_element( file );
2124                 attr = xml_get_current_tag_attr( file );
2125                 /* show_attribs( attr ); */
2126                 /* printf( "\ttag  value : %s :\n", element ); */
2127                 addrindex_consume_tree( file );
2128         }
2129 }
2130
2131 static gint addrindex_convert_data( AddressIndex *addrIndex ) {
2132         XMLFile *file = NULL;
2133         gchar *fileSpec;
2134
2135         fileSpec = g_strconcat( addrIndex->filePath, G_DIR_SEPARATOR_S, addrIndex->fileName, NULL );
2136         addrIndex->retVal = MGU_NO_FILE;
2137         file = xml_open_file( fileSpec );
2138         g_free( fileSpec );
2139
2140         if( file == NULL ) {
2141                 /* fprintf( stdout, " file '%s' does not exist.\n", addrIndex->fileName ); */
2142                 return addrIndex->retVal;
2143         }
2144
2145         addrIndex->retVal = MGU_BAD_FORMAT;
2146         if( xml_get_dtd( file ) == 0 ) {
2147                 if( xml_parse_next_tag( file ) == 0 ) {
2148                         if( xml_compare_tag( file, TAG_ADDRESS_INDEX ) ) {
2149                                 addrindex_convert_tree( addrIndex, file );
2150                         }
2151                 }
2152         }
2153         xml_close_file( file );
2154         return addrIndex->retVal;
2155 }
2156
2157 /*
2158 * Create a new address book file.
2159 */
2160 static gboolean addrindex_create_new_book( AddressIndex *addrIndex, gchar *displayName ) {
2161         gboolean retVal = FALSE;
2162         AddressBookFile *abf = NULL;
2163         gchar *newFile = NULL;
2164         GList *fileList = NULL;
2165         gint fileNum = 0;
2166
2167         /* Create new address book */
2168         abf = addrbook_create_book();
2169         addrbook_set_name( abf, displayName );
2170         addrbook_set_path( abf, addrIndex->filePath );
2171
2172         /* Determine next available file number */
2173         fileList = addrbook_get_bookfile_list( abf );
2174         if( fileList ) {
2175                 fileNum = 1 + abf->maxValue;
2176         }
2177         g_list_free( fileList );
2178         fileList = NULL;
2179
2180         newFile = addrbook_gen_new_file_name( fileNum );
2181         if( newFile ) {
2182                 addrbook_set_file( abf, newFile );
2183         }
2184
2185         addrbook_save_data( abf );
2186         addrIndex->retVal = abf->retVal;
2187         if( abf->retVal == MGU_SUCCESS ) retVal = TRUE;
2188         addrbook_free_book( abf );
2189         abf = NULL;
2190
2191         /* Create entries in address index */
2192         if( retVal ) {
2193                 abf = addrbook_create_book();
2194                 addrbook_set_name( abf, displayName );
2195                 addrbook_set_path( abf, addrIndex->filePath );
2196                 addrbook_set_file( abf, newFile );
2197                 addrindex_index_add_datasource( addrIndex, ADDR_IF_BOOK, abf );
2198         }
2199
2200         return retVal;
2201 }
2202
2203 /*
2204 * Read data for address index performing a conversion if necesary.
2205 * Enter: addrIndex Address index object.
2206 * return: Status code, from addrIndex->retVal.
2207 * Note: New address book files will be created in directory specified by
2208 * addrIndex. Three files will be created, for the following:
2209 *       "Common addresses"
2210 *       "Personal addresses"
2211 *       "Gathered addresses" - a new address book.
2212 */
2213 gint addrindex_read_data( AddressIndex *addrIndex ) {
2214         g_return_val_if_fail( addrIndex != NULL, -1 );
2215
2216         addrIndex->conversionError = FALSE;
2217         addrindex_read_file( addrIndex );
2218         if( addrIndex->retVal == MGU_SUCCESS ) {
2219                 if( addrIndex->needsConversion ) {
2220                         if( addrindex_convert_data( addrIndex ) == MGU_SUCCESS ) {
2221                                 addrIndex->conversionError = TRUE;
2222                         }
2223                         else {
2224                                 addrIndex->conversionError = TRUE;
2225                         }
2226                 }
2227                 addrIndex->dirtyFlag = TRUE;
2228         }
2229         return addrIndex->retVal;
2230 }
2231
2232 /*
2233 * Create new address books for a new address index.
2234 * Enter: addrIndex Address index object.
2235 * return: Status code, from addrIndex->retVal.
2236 * Note: New address book files will be created in directory specified by
2237 * addrIndex. Three files will be created, for the following:
2238 *       "Common addresses"
2239 *       "Personal addresses"
2240 *       "Gathered addresses" - a new address book.
2241 */
2242 gint addrindex_create_new_books( AddressIndex *addrIndex ) {
2243         gboolean flg;
2244
2245         g_return_val_if_fail( addrIndex != NULL, -1 );
2246
2247         flg = addrindex_create_new_book( addrIndex, DISP_NEW_COMMON );
2248         if( flg ) {
2249                 flg = addrindex_create_new_book( addrIndex, DISP_NEW_PERSONAL );
2250                 addrIndex->dirtyFlag = TRUE;
2251         }
2252         return addrIndex->retVal;
2253 }
2254
2255 /* **********************************************************************
2256 * New interface stuff.
2257 * ***********************************************************************
2258 */
2259
2260 /*
2261  * Return modified flag for specified data source.
2262  */
2263 gboolean addrindex_ds_get_modify_flag( AddressDataSource *ds ) {
2264         gboolean retVal = FALSE;
2265         AddressInterface *iface;
2266
2267         if( ds == NULL ) return retVal;
2268         iface = ds->interface;
2269         if( iface == NULL ) return retVal;
2270         if( iface->getModifyFlag ) {
2271                 retVal = ( iface->getModifyFlag ) ( ds->rawDataSource );
2272         }
2273         return retVal;
2274 }
2275
2276 /*
2277  * Return accessed flag for specified data source.
2278  */
2279 gboolean addrindex_ds_get_access_flag( AddressDataSource *ds ) {
2280         gboolean retVal = FALSE;
2281         AddressInterface *iface;
2282
2283         if( ds == NULL ) return retVal;
2284         iface = ds->interface;
2285         if( iface == NULL ) return retVal;
2286         if( iface->getAccessFlag ) {
2287                 retVal = ( iface->getAccessFlag ) ( ds->rawDataSource );
2288         }
2289         return retVal;
2290 }
2291
2292 /*
2293  * Return data read flag for specified data source.
2294  */
2295 gboolean addrindex_ds_get_read_flag( AddressDataSource *ds ) {
2296         gboolean retVal = TRUE;
2297         AddressInterface *iface;
2298
2299         if( ds == NULL ) return retVal;
2300         iface = ds->interface;
2301         if( iface == NULL ) return retVal;
2302         if( iface->getReadFlag ) {
2303                 retVal = ( iface->getReadFlag ) ( ds->rawDataSource );
2304         }
2305         return retVal;
2306 }
2307
2308 /*
2309  * Return status code for specified data source.
2310  */
2311 gint addrindex_ds_get_status_code( AddressDataSource *ds ) {
2312         gint retVal = MGU_SUCCESS;
2313         AddressInterface *iface;
2314
2315         if( ds == NULL ) return retVal;
2316         iface = ds->interface;
2317         if( iface == NULL ) return retVal;
2318         if( iface->getStatusCode ) {
2319                 retVal = ( iface->getStatusCode ) ( ds->rawDataSource );
2320         }
2321         return retVal;
2322 }
2323
2324 /*
2325  * Return data read flag for specified data source.
2326  */
2327 gint addrindex_ds_read_data( AddressDataSource *ds ) {
2328         gint retVal = MGU_SUCCESS;
2329         AddressInterface *iface;
2330
2331         if( ds == NULL ) return retVal;
2332         iface = ds->interface;
2333         if( iface == NULL ) return retVal;
2334         if( iface->getReadData ) {
2335                 /*
2336                 gchar *name = ( iface->getName ) ( ds->rawDataSource );
2337                 printf( "addrindex_ds_read_data...reading:::%s:::\n", name );
2338                 */
2339                 retVal = ( iface->getReadData ) ( ds->rawDataSource );
2340         }
2341         return retVal;
2342 }
2343
2344 /*
2345  * Return data read flag for specified data source.
2346  */
2347 ItemFolder *addrindex_ds_get_root_folder( AddressDataSource *ds ) {
2348         ItemFolder *retVal = NULL;
2349         AddressInterface *iface;
2350
2351         if( ds == NULL ) return retVal;
2352         iface = ds->interface;
2353         if( iface == NULL ) return retVal;
2354         if( iface->getRootFolder ) {
2355                 retVal = ( iface->getRootFolder ) ( ds->rawDataSource );
2356         }
2357         return retVal;
2358 }
2359
2360 /*
2361  * Return name for specified data source.
2362  */
2363 gchar *addrindex_ds_get_name( AddressDataSource *ds ) {
2364         gchar *retVal = FALSE;
2365         AddressInterface *iface;
2366
2367         if( ds == NULL ) return retVal;
2368         iface = ds->interface;
2369         if( iface == NULL ) return retVal;
2370         if( iface->getName ) {
2371                 retVal = ( iface->getName ) ( ds->rawDataSource );
2372         }
2373         return retVal;
2374 }
2375
2376 /*
2377  * Set the access flag inside the data source.
2378  */
2379 void addrindex_ds_set_access_flag( AddressDataSource *ds, gboolean *value ) {
2380         AddressInterface *iface;
2381
2382         if( ds == NULL ) return;
2383         iface = ds->interface;
2384         if( iface == NULL ) return;
2385         if( iface->setAccessFlag ) {
2386                 ( iface->setAccessFlag ) ( ds->rawDataSource, value );
2387         }
2388 }
2389
2390 /*
2391  * Return read only flag for specified data source.
2392  */
2393 gboolean addrindex_ds_get_readonly( AddressDataSource *ds ) {
2394         AddressInterface *iface;
2395         if( ds == NULL ) return TRUE;
2396         iface = ds->interface;
2397         if( iface == NULL ) return TRUE;
2398         return iface->readOnly;
2399 }
2400
2401 /*
2402  * Return list of all persons for specified data source.
2403  */
2404 static GList *addrindex_ds_get_all_persons( AddressDataSource *ds ) {
2405         GList *retVal = NULL;
2406         AddressInterface *iface;
2407
2408         if( ds == NULL ) return retVal;
2409         iface = ds->interface;
2410         if( iface == NULL ) return retVal;
2411         if( iface->getAllPersons ) {
2412                 retVal = ( iface->getAllPersons ) ( ds->rawDataSource );
2413         }
2414         return retVal;
2415 }
2416
2417 /*
2418  * Return list of all groups for specified data source.
2419  */
2420 static GList *addrindex_ds_get_all_groups( AddressDataSource *ds ) {
2421         GList *retVal = NULL;
2422         AddressInterface *iface;
2423
2424         if( ds == NULL ) return retVal;
2425         iface = ds->interface;
2426         if( iface == NULL ) return retVal;
2427         if( iface->getAllGroups ) {
2428                 retVal = ( iface->getAllGroups ) ( ds->rawDataSource );
2429         }
2430         return retVal;
2431 }
2432
2433 /* **********************************************************************
2434 * Address search stuff.
2435 * ***********************************************************************
2436 */
2437
2438 /**
2439  * Setup or register the dynamic search that will be performed. The search
2440  * is registered with the query manager.
2441  *
2442  * \param searchTerm    Search term. A private copy will be made.
2443  * \param callBackEntry Callback function that should be called when
2444  *                      each entry is received.
2445  * \param callBackEnd   Callback function that should be called when
2446  *                      search has finished running.
2447  * \return ID allocated to query that will be executed.
2448  */
2449 gint addrindex_setup_search(
2450         const gchar *searchTerm, void *callBackEnd, void *callBackEntry )
2451 {
2452         QueryRequest *req;
2453         gint queryID;
2454
2455         /* Set up a dynamic address query */
2456         req = qrymgr_add_request( searchTerm, callBackEnd, callBackEntry );
2457         queryID = req->queryID;
2458         qryreq_set_search_type( req, ADDRSEARCH_DYNAMIC );
2459
2460         /* printf( "***> query ID ::%d::\n", queryID ); */
2461         return queryID;
2462 }
2463
2464 #ifdef USE_LDAP
2465
2466 /*
2467  * Function prototypes (not in header file or circular reference errors are
2468  * encountered!)
2469  */
2470 LdapQuery *ldapsvr_new_dynamic_search( 
2471                 LdapServer *server, QueryRequest *req );
2472 LdapQuery *ldapsvr_new_explicit_search(
2473                 LdapServer *server, QueryRequest *req, ItemFolder *folder );
2474 void ldapsvr_execute_query( LdapServer *server, LdapQuery *qry );
2475
2476 #endif
2477
2478 /**
2479  * Execute the previously registered dynamic search.
2480  *
2481  * \param  req Address query object to execute.
2482  * \return <i>TRUE</i> if search started successfully, or <i>FALSE</i> if
2483  *         failed.
2484  */
2485 static gboolean addrindex_start_dynamic( QueryRequest *req ) {
2486         AddressInterface *iface;
2487         AddressDataSource *ds;
2488         GList *nodeIf;
2489         GList *nodeDS;
2490         gint type;
2491
2492         /* printf( "addrindex_start_dynamic::%d::\n", req->queryID ); */
2493         nodeIf = _addressIndex_->searchOrder;
2494         while( nodeIf ) {
2495                 iface = nodeIf->data;
2496                 nodeIf = g_list_next( nodeIf );
2497
2498                 if( ! iface->useInterface ) {
2499                         continue;
2500                 }
2501                 if( ! iface->externalQuery ) {
2502                         continue;
2503                 }
2504
2505                 type = iface->type;
2506                 nodeDS = iface->listSource;
2507                 while( nodeDS ) {
2508                         ds = nodeDS->data;
2509                         nodeDS = g_list_next( nodeDS );
2510 #ifdef USE_LDAP
2511                         if( type == ADDR_IF_LDAP ) {
2512                                 LdapServer *server;
2513                                 LdapQuery *qry;
2514
2515                                 server = ds->rawDataSource;
2516                                 if( ! server->searchFlag ) {
2517                                         continue;
2518                                 }
2519                                 if( ldapsvr_reuse_previous( server, req ) ) {
2520                                         continue;
2521                                 }
2522
2523                                 /* Start a new dynamic search */
2524                                 qry = ldapsvr_new_dynamic_search( server, req );
2525                                 if( qry ) {
2526                                         ldapsvr_execute_query( server, qry );
2527                                 }
2528                         }
2529 #endif
2530                 }
2531         }
2532         return TRUE;
2533 }
2534
2535 /**
2536  * Stop the previously registered search.
2537  *
2538  * \param queryID ID of search query to stop.
2539  */
2540 void addrindex_stop_search( const gint queryID ){
2541         QueryRequest *req;
2542         AddrQueryObject *aqo;
2543         GList *node;
2544
2545         /* printf( "addrindex_stop_search/queryID=%d\n", queryID ); */
2546         /* If query ID does not match, search has not been setup */
2547         req = qrymgr_find_request( queryID );
2548         if( req == NULL ) {
2549                 return;
2550         }
2551
2552         /* Stop all queries that were associated with request */
2553         node = req->queryList;
2554         while( node ) {
2555                 aqo = node->data;
2556 #ifdef USE_LDAP
2557                 if( aqo->queryType == ADDRQUERY_LDAP ) {
2558                         LdapQuery *qry = ( LdapQuery * ) aqo;
2559                         ldapqry_set_stop_flag( qry, TRUE );
2560                 }
2561 #endif
2562                 node->data = NULL;
2563                 node = g_list_next( node );
2564         }
2565
2566         /* Delete query request */
2567         qrymgr_delete_request( queryID );
2568 }
2569
2570 /**
2571  * Setup or register the explicit search that will be performed. The search is
2572  * registered with the query manager.
2573  *
2574  * \param  ds            Data source to search.
2575  * \param  searchTerm    Search term to locate.
2576  * \param  folder        Folder to receive search results; may be NULL.
2577  * \param  callbackEnd   Function to call when search has terminated.
2578  * \param  callbackEntry Function to called for each entry processed.
2579  * \return ID allocated to query that will be executed.
2580  */
2581 gint addrindex_setup_explicit_search(
2582         AddressDataSource *ds, const gchar *searchTerm, ItemFolder *folder,
2583         void *callBackEnd, void *callBackEntry )
2584 {
2585         QueryRequest *req;
2586         gint queryID;
2587         gchar *name;
2588         gchar *mySearch;
2589
2590         /* Name the query */
2591         name = g_strdup_printf( "Search '%s'", searchTerm );
2592
2593         /* Set up query request */
2594         if (!strcmp(searchTerm, "*"))
2595                 mySearch = g_strdup("*@");
2596         else
2597                 mySearch = g_strdup(searchTerm);
2598         
2599         req = qrymgr_add_request( mySearch, callBackEnd, callBackEntry );
2600
2601         g_free(mySearch);
2602
2603         qryreq_set_search_type( req, ADDRSEARCH_EXPLICIT );
2604         queryID = req->queryID;
2605
2606         if( ds->type == ADDR_IF_LDAP ) {
2607 #ifdef USE_LDAP
2608                 LdapServer *server;
2609
2610                 server = ds->rawDataSource;
2611                 ldapsvr_new_explicit_search( server, req, folder );
2612 #endif
2613         }
2614         else {
2615                 qrymgr_delete_request( queryID );
2616                 queryID = 0;
2617         }
2618         g_free( name );
2619
2620         return queryID;
2621 }
2622
2623 /**
2624  * Execute the previously registered explicit search.
2625  *
2626  * \param  req Address query request object to execute.
2627  * \return <i>TRUE</i> if search started successfully, or <i>FALSE</i> if
2628  *         failed.
2629  */
2630 static gboolean addrindex_start_explicit( QueryRequest *req ) {
2631         gboolean retVal;
2632         AddrQueryObject *aqo;
2633
2634         retVal = FALSE;
2635
2636         /* Note: there should only be one query in the list. */
2637         aqo = req->queryList->data;
2638 #ifdef USE_LDAP
2639         if( aqo->queryType == ADDRQUERY_LDAP ) {
2640                 LdapServer *server;
2641                 LdapQuery *qry;
2642
2643                 qry = ( LdapQuery * ) aqo;
2644                 server = qry->server;
2645
2646                 /* Start the search */
2647                 retVal = TRUE;
2648                 ldapsvr_execute_query( server, qry );
2649         }
2650 #endif
2651         return retVal;
2652 }
2653
2654 /**
2655  * Start the previously registered search.
2656  *
2657  * \param  queryID    ID of search query to be executed.
2658  * \return <i>TRUE</i> if search started successfully, or <i>FALSE</i> if
2659  *         failed.
2660  */
2661 gboolean addrindex_start_search( const gint queryID ) {
2662         gboolean retVal;
2663         QueryRequest *req;
2664         AddrSearchType searchType;
2665
2666         retVal = FALSE;
2667         /* printf( "addrindex_start_search/queryID=%d\n", queryID ); */
2668         req = qrymgr_find_request( queryID );
2669         if( req == NULL ) {
2670                 return retVal;
2671         }
2672
2673         searchType = req->searchType;
2674         if( searchType == ADDRSEARCH_DYNAMIC ) {
2675                 retVal = addrindex_start_dynamic( req );
2676         }
2677         else if( searchType == ADDRSEARCH_EXPLICIT ) {
2678                 retVal = addrindex_start_explicit( req );
2679         }
2680
2681         return retVal;
2682 }
2683
2684 /**
2685  * Remove results (folder and data) for specified data source and folder.
2686  * \param ds     Data source to process.
2687  * \param folder Results folder to remove.
2688  */
2689 void addrindex_remove_results( AddressDataSource *ds, ItemFolder *folder ) {
2690         AddrBookBase *adbase;
2691         AddressCache *cache;
2692         gint queryID = 0;
2693
2694         /* printf( "addrindex_remove_results/start\n" ); */
2695
2696         /* Test for folder */
2697         if( folder->folderType != ADDRFOLDER_QUERY_RESULTS ) return;
2698         /* printf( "folder name ::%s::\n", ADDRITEM_NAME(folder) ); */
2699         adbase = ( AddrBookBase * ) ds->rawDataSource;
2700         if( adbase == NULL ) return;
2701         cache = adbase->addressCache;
2702
2703         /* Hide folder to prevent re-display */
2704         addritem_folder_set_hidden( folder, TRUE );
2705
2706         if( ds->type == ADDR_IF_LDAP ) {
2707 #ifdef USE_LDAP
2708                 LdapQuery *qry;
2709                 gboolean  delFlag;
2710
2711                 qry = ( LdapQuery * ) folder->folderData;
2712                 queryID = ADDRQUERY_ID(qry);
2713                 /* printf( "calling ldapquery_remove_results...queryID=%d\n", queryID ); */
2714                 delFlag = ldapquery_remove_results( qry );
2715                 if (delFlag) {
2716                         ldapqry_free( qry );
2717                 }
2718                 /* printf( "calling ldapquery_remove_results...done\n" ); */
2719                 /*
2720                 if( delFlag ) {
2721                         printf( "delFlag IS-TRUE\n" );
2722                 }
2723                 else {
2724                         printf( "delFlag IS-FALSE\n" );
2725                 }
2726                 */
2727 #endif
2728         }
2729         /* printf( "addrindex_remove_results/end\n" ); */
2730
2731         /* Delete query request */
2732         if( queryID > 0 ) {
2733                 qrymgr_delete_request( queryID );
2734         }
2735 }
2736
2737 /* **********************************************************************
2738 * Address completion stuff.
2739 * ***********************************************************************
2740 */
2741
2742 static void addrindex_load_completion_load_persons(
2743                 gint (*callBackFunc) ( const gchar *, const gchar *, 
2744                                        const gchar *, const gchar *, GList * ),
2745                 AddressDataSource *ds)
2746 {
2747         GList *listP, *nodeP;
2748         GList *nodeM;
2749         gchar *sName;
2750
2751         /* Read address book */
2752         if( addrindex_ds_get_modify_flag( ds ) ) {
2753                 addrindex_ds_read_data( ds );
2754         }
2755
2756         if( ! addrindex_ds_get_read_flag( ds ) ) {
2757                 addrindex_ds_read_data( ds );
2758         }
2759
2760         /* Get all groups */
2761         listP = addrindex_ds_get_all_groups( ds );
2762         nodeP = listP;
2763         while( nodeP ) {
2764                 ItemGroup *group = nodeP->data;
2765                 GList *emails = NULL;
2766                 for (nodeM = group->listEMail; nodeM; nodeM = g_list_next(nodeM)) {
2767                         ItemEMail *email = nodeM->data;
2768                         if (email->address)
2769                                 emails = g_list_append(emails, email);
2770                 }
2771                 callBackFunc( ((AddrItemObject *)group)->name, NULL,
2772                               NULL, NULL, emails );
2773                 nodeP = g_list_next( nodeP );
2774         }
2775
2776         /* Free up the list */
2777         g_list_free( listP );
2778         /* Get all persons */
2779         listP = addrindex_ds_get_all_persons( ds );
2780         nodeP = listP;
2781         while( nodeP ) {
2782                 ItemPerson *person = nodeP->data;
2783                 nodeM = person->listEMail;
2784
2785                 /* Figure out name to use */
2786                 sName = ADDRITEM_NAME(person);
2787                 if( sName == NULL || *sName == '\0' ) {
2788                         sName = person->nickName;
2789                 }
2790
2791                 /* Process each E-Mail address */
2792                 while( nodeM ) {
2793                         ItemEMail *email = nodeM->data;
2794
2795                         callBackFunc( sName, email->address, person->nickName, 
2796                                       ADDRITEM_NAME(email), NULL );
2797
2798                         nodeM = g_list_next( nodeM );
2799                 }
2800                 nodeP = g_list_next( nodeP );
2801         }
2802
2803         /* Free up the list */
2804         g_list_free( listP );
2805 }               
2806
2807 /**
2808  * This function is used by the address completion function to load
2809  * addresses for all non-external address book interfaces.
2810  *
2811  * \param callBackFunc Function to be called when an address is
2812  *                     to be loaded.
2813  * \param folderpath Addressbook's Book/folder path to restrict to (if NULL or ""
2814  *                     or "Any", assume the whole addressbook
2815  * \return <i>TRUE</i> if data loaded, <i>FALSE</i> if address index not loaded.
2816  */
2817
2818 gboolean addrindex_load_completion(
2819                 gint (*callBackFunc) ( const gchar *, const gchar *, 
2820                                        const gchar *, const gchar *, GList * ),
2821                 gchar *folderpath )
2822 {
2823         GList *nodeIf, *nodeDS;
2824
2825         if( folderpath != NULL ) {
2826                 AddressDataSource *book;
2827                 ItemFolder* folder;
2828
2829                 /* split the folder path we've received, we'll try to match this path, subpath by
2830                    subpath against the book/folder structure in order and restrict loading of
2831                    addresses to that subpart (if matches). book/folder path must exist and
2832                    folderpath must not be empty or NULL */
2833                 
2834                 if( ! addressbook_peek_folder_exists( folderpath, &book, &folder ) ) {
2835                         g_warning("addrindex_load_completion: folder path '%s' doesn't exist\n", folderpath);
2836                         return FALSE;
2837                 }
2838
2839                 if( folder != NULL ) {
2840
2841                         GList *items;
2842                         GList *nodeM;
2843                         gchar *sName;
2844                         ItemPerson *person;
2845
2846                         debug_print("addrindex_load_completion: folder %p '%s'\n", folder, folder->obj.name);
2847
2848                         /* Load email addresses */
2849                         items = addritem_folder_get_person_list( folder );
2850                         for( ; items != NULL; items = g_list_next( items ) ) {
2851                                 person = items->data;
2852                                 nodeM = person->listEMail;
2853
2854                                 /* Figure out name to use */
2855                                 sName = ADDRITEM_NAME(person);
2856                                 if( sName == NULL || *sName == '\0' ) {
2857                                         sName = person->nickName;
2858                                 }
2859
2860                                 /* Process each E-Mail address */
2861                                 while( nodeM ) {
2862                                         ItemEMail *email = nodeM->data;
2863
2864                                         callBackFunc( sName, email->address, person->nickName, 
2865                                                           ADDRITEM_NAME(email), NULL );
2866
2867                                         nodeM = g_list_next( nodeM );
2868                                 }
2869                         }
2870                         /* Free up the list */
2871                         mgu_clear_list( items );
2872                         g_list_free( items );
2873
2874                         return TRUE;
2875
2876                 } else {
2877
2878                         if( book != NULL ) {
2879
2880                                 AddressBookFile *abf = book->rawDataSource;
2881
2882                                 debug_print("addrindex_load_completion: book %p '%s'\n", book, abf->fileName);
2883
2884                                 addrindex_load_completion_load_persons( callBackFunc, book );
2885
2886                                 return TRUE;
2887
2888                         } else {
2889                                 g_warning("addrindex_load_completion: book/folder path is valid but got no pointer\n");
2890                         }
2891                 }
2892                 return FALSE;
2893
2894         } else {
2895
2896                 nodeIf = addrindex_get_interface_list( _addressIndex_ );
2897                 while( nodeIf ) {
2898                         AddressInterface *iface = nodeIf->data;
2899
2900                         nodeIf = g_list_next( nodeIf );
2901
2902                         if( ! iface->useInterface || iface->externalQuery )
2903                                 continue;
2904
2905                         nodeDS = iface->listSource;
2906                         while( nodeDS ) {
2907                                 addrindex_load_completion_load_persons( callBackFunc, nodeDS->data );
2908                         nodeDS = g_list_next( nodeDS );
2909                 }
2910         }
2911         }
2912
2913         return TRUE;
2914 }
2915
2916 /**
2917  * This function can be used to collect information about
2918  * addressbook entries that contain a specific attribute.
2919  *
2920  * \param attr         Name of attribute to look for
2921  * \param callBackFunc Function to be called when a matching attribute was found
2922  * \return <i>TRUE</i>
2923  */
2924 gboolean addrindex_load_person_attribute(
2925                 const gchar *attr,
2926                 gint (*callBackFunc) ( ItemPerson *, const gchar * ) )
2927 {
2928         AddressDataSource *ds;
2929         GList *nodeIf, *nodeDS;
2930         GList *listP, *nodeP;
2931         GList *nodeA;
2932
2933         nodeIf = addrindex_get_interface_list( _addressIndex_ );
2934         while( nodeIf ) {
2935                 gchar *cur_bname;
2936                 AddressInterface *iface = nodeIf->data;
2937
2938                 nodeIf = g_list_next( nodeIf );
2939
2940                 if( ! iface->useInterface || iface->externalQuery )
2941                         continue;
2942
2943                 nodeDS = iface->listSource;
2944                 while( nodeDS ) {
2945                         ds = nodeDS->data;
2946
2947                         /* Read address book */
2948                         if( addrindex_ds_get_modify_flag( ds ) ) {
2949                                 addrindex_ds_read_data( ds );
2950                         }
2951
2952                         if( ! addrindex_ds_get_read_flag( ds ) ) {
2953                                 addrindex_ds_read_data( ds );
2954                         }
2955
2956                         /* Check addressbook name */
2957                         cur_bname = addrindex_ds_get_name( ds );
2958
2959                         /* Get all persons */
2960                         listP = addrindex_ds_get_all_persons( ds );
2961                         nodeP = listP;
2962                         while( nodeP ) {
2963                                 ItemPerson *person = nodeP->data;
2964
2965                                 /* Return all ItemPerson's if attr is NULL */
2966                                 if( attr == NULL ) {
2967                                         callBackFunc(person, cur_bname);
2968                                 }
2969
2970                                 /* Return ItemPerson's with specific attribute */
2971                                 else {
2972                                         nodeA = person->listAttrib;
2973                                         /* Process each User Attribute */
2974                                         while( nodeA ) {
2975                                                 UserAttribute *attrib = nodeA->data;
2976                                                 if( attrib->name && 
2977                                                     !strcmp( attrib->name,attr ) ) {
2978                                                         callBackFunc(person, cur_bname);
2979                                                 }
2980                                                 nodeA = g_list_next( nodeA );
2981                                         }
2982                                 }
2983                                 nodeP = g_list_next( nodeP );
2984                         }
2985                         /* Free up the list */
2986                         g_list_free( listP );
2987
2988                         nodeDS = g_list_next( nodeDS );
2989                 }
2990         }
2991         return TRUE;
2992 }
2993
2994 /*
2995  * End of Source.
2996  */