ff5582649addb916ea493e40145268bc0f43d145
[claws.git] / src / ldapquery.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2003-2007 Match Grun and the Claws Mail team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  * 
18  */
19
20 /*
21  * Functions necessary to define and perform LDAP queries.
22  */
23
24 #ifdef HAVE_CONFIG_H
25 #  include "config.h"
26 #endif
27
28 #ifdef USE_LDAP
29
30 #include <glib.h>
31 #include <sys/time.h>
32 #include <string.h>
33 #include <lber.h>
34
35 #include "ldaputil.h"
36 #include "ldapquery.h"
37 #include "ldapctrl.h"
38 #include "mgutils.h"
39
40 #include "addritem.h"
41 #include "addrcache.h"
42 #include "common/utils.h"
43
44 /*
45  * Key for thread specific data.
46  */
47 static pthread_key_t _queryThreadKey_;
48 static gboolean _queryThreadInit_ = FALSE;
49
50 static gboolean callbackend (gpointer data)
51 {
52         LdapQuery *qry = (LdapQuery *)data;
53         qry->callBackEnd( qry, ADDRQUERY_ID(qry), ADDRQUERY_RETVAL(qry), qry->data );
54         return FALSE;
55 }
56
57
58 /**
59  * Create new LDAP query object.
60  * \return Initialized query object.
61  */
62 LdapQuery *ldapqry_create( void ) {
63         LdapQuery *qry;
64
65         qry = g_new0( LdapQuery, 1 );
66         ADDRQUERY_TYPE(qry) = ADDRQUERY_LDAP;
67         ADDRQUERY_ID(qry) = 0;
68         ADDRQUERY_SEARCHTYPE(qry) = ADDRSEARCH_NONE;
69         ADDRQUERY_NAME(qry) = NULL;
70         ADDRQUERY_RETVAL(qry) = LDAPRC_SUCCESS;
71         ADDRQUERY_FOLDER(qry) = NULL;
72         ADDRQUERY_SEARCHVALUE(qry) = NULL;
73         qry->control = NULL;
74         qry->server = NULL;
75         qry->entriesRead = 0;
76         qry->elapsedTime = 0;
77         qry->stopFlag = FALSE;
78         qry->busyFlag = FALSE;
79         qry->agedFlag = FALSE;
80         qry->completed = FALSE;
81         qry->thread = NULL;
82         qry->callBackEntry = NULL;
83         qry->callBackEnd = NULL;
84         qry->ldap = NULL;
85         qry->data = NULL;
86
87         /* Mutex to protect stop and busy flags */
88         qry->mutexStop = g_malloc0( sizeof( pthread_mutex_t ) );
89         pthread_mutex_init( qry->mutexStop, NULL );
90         qry->mutexBusy = g_malloc0( sizeof( pthread_mutex_t ) );
91         pthread_mutex_init( qry->mutexBusy, NULL );
92
93         /* Mutex to protect critical section */
94         qry->mutexEntry = g_malloc0( sizeof( pthread_mutex_t ) );
95         pthread_mutex_init( qry->mutexEntry, NULL );
96
97         return qry;
98 }
99
100 /**
101  * Specify the reference to control data that will be used for the query. The calling
102  * module should be responsible for creating and destroying this control object.
103  * \param qry Query object.
104  * \param ctl Control object.
105  */
106 void ldapqry_set_control( LdapQuery *qry, LdapControl *ctl ) {
107         g_return_if_fail( qry != NULL );
108         qry->control = ctl;
109 }
110
111 /**
112  * Specify query name to be used.
113  * \param qry   Query object.
114  * \param value Name.
115  */
116 void ldapqry_set_name( LdapQuery* qry, const gchar *value ) {
117         g_return_if_fail( qry != NULL );
118         g_return_if_fail( ADDRQUERY_OBJECT(qry) != NULL );
119         ADDRQUERY_NAME(qry) = mgu_replace_string( ADDRQUERY_NAME(qry), value );
120         g_strstrip( ADDRQUERY_NAME(qry) );
121         debug_print("set name: %s\n", ADDRQUERY_NAME(qry));
122 }
123
124 /**
125  * Specify search value to be used.
126  * \param qry Query object.
127  * \param value 
128  */
129 void ldapqry_set_search_value( LdapQuery *qry, const gchar *value ) {
130         g_return_if_fail( qry != NULL );
131         g_return_if_fail( ADDRQUERY_OBJECT(qry) != NULL );
132         ADDRQUERY_SEARCHVALUE(qry) = mgu_replace_string( ADDRQUERY_SEARCHVALUE(qry), value );
133         g_strstrip( ADDRQUERY_SEARCHVALUE(qry) );
134         debug_print("search value: %s\n", ADDRQUERY_SEARCHVALUE(qry));
135 }
136
137 /**
138  * Specify query type.
139  * \param qry Query object.
140  * \param value Query type, either:
141  * <ul>
142  * <li><code>LDAPQUERY_NONE</code></li>
143  * <li><code>LDAPQUERY_STATIC</code></li>
144  * <li><code>LDAPQUERY_DYNAMIC</code></li>
145  * </ul>
146  */
147 /*
148 void ldapqry_set_query_type( LdapQuery* qry, const gint value ) {
149         ADDRQUERY_TYPE(qry) = value;
150 }
151 */
152
153 /**
154  * Specify search type.
155  * \param qry   Query object.
156  * \param value Type.
157  */
158 void ldapqry_set_search_type( LdapQuery *qry, const AddrSearchType value ) {
159         g_return_if_fail( qry != NULL );
160         g_return_if_fail( ADDRQUERY_OBJECT(qry) != NULL );
161         ADDRQUERY_SEARCHTYPE(qry) = value;
162 }
163
164 /**
165  * Specify query ID.
166  * \param qry Query object.
167  * \param value ID for the query.
168  */
169 void ldapqry_set_query_id( LdapQuery* qry, const gint value ) {
170         g_return_if_fail( qry != NULL );
171         g_return_if_fail( ADDRQUERY_OBJECT(qry) != NULL );
172         ADDRQUERY_ID(qry) = value;
173 }
174
175 /**
176  * Register a callback function that will be executed when each entry
177  * has been read and processed. When called, the function will be passed
178  * this query object and a GList of ItemEMail objects as arguments. An
179  * example of typical usage is shown below.
180  *
181  * <pre>
182  * ------------------------------------------------------------
183  * void myCallbackEntry( LdapQuery *qry, GList *listEMail ) {
184  *   GList *node;
185  *
186  *   node = listEMail;
187  *   while( node ) {
188  *     ItemEMail *email = node->data;
189  *     ... process email object ...
190  *     node = g_list_next( node );
191  *   }
192  *   g_list_free( listEMail );
193  * }
194  * ...
195  * ...
196  * ldapqry_set_callback_entry( qry, myCallbackEntry );
197  * ------------------------------------------------------------
198  * </pre>
199  *
200  * \param qry Query object.
201  * \param func Function.
202  */
203 void ldapqry_set_callback_entry( LdapQuery *qry, void *func ) {
204         pthread_mutex_lock( qry->mutexEntry );
205         qry->callBackEntry = func;
206         pthread_mutex_unlock( qry->mutexEntry );
207 }
208
209 /**
210  * Register a callback function that will be executed when the search
211  * is complete. When called, the function will be passed this query
212  * object as an argument.
213  * \param qry Query object.
214  * \param func Function.
215  */
216 void ldapqry_set_callback_end( LdapQuery *qry, void *func ) {
217         qry->callBackEnd = func;
218 }
219
220 /**
221  * Notify query to start/stop executing. This method should be called with a
222  * value if <i>TRUE</i> to terminate an existing running query.
223  *
224  * \param qry Query object.
225  * \param value Value of stop flag.
226  */
227 void ldapqry_set_stop_flag( LdapQuery *qry, const gboolean value ) {
228         g_return_if_fail( qry != NULL );
229
230         pthread_mutex_lock( qry->mutexStop );
231         qry->stopFlag = value;
232         pthread_mutex_unlock( qry->mutexStop );
233 }
234
235 /**
236  * Test value of stop flag. This method should be used to determine whether a
237  * query has stopped running.
238  * \param qry Query object.
239  * \return Value of stop flag.
240  */
241 static gboolean ldapqry_get_stop_flag( LdapQuery *qry ) {
242         gboolean value;
243         g_return_val_if_fail( qry != NULL, TRUE );
244
245         pthread_mutex_lock( qry->mutexStop );
246         value = qry->stopFlag;
247         pthread_mutex_unlock( qry->mutexStop );
248         return value;
249 }
250
251 /**
252  * Set busy flag.
253  * \param qry Query object.
254  * \param value Value of busy flag.
255  */
256 static void ldapqry_set_busy_flag( LdapQuery *qry, const gboolean value ) {
257         g_return_if_fail( qry != NULL );
258         if (qry->mutexBusy == NULL)
259                 return; /* exiting, mutex already freed */
260
261         pthread_mutex_lock( qry->mutexBusy );
262         qry->busyFlag = value;
263         pthread_mutex_unlock( qry->mutexBusy );
264 }
265
266 /**
267  * Test value of busy flag. This method will return a value of <i>FALSE</i>
268  * when a query has completed running.
269  * \param qry Query object.
270  * \return Value of busy flag.
271  */
272 static gboolean ldapqry_get_busy_flag( LdapQuery *qry ) {
273         gboolean value;
274         g_return_val_if_fail( qry != NULL, FALSE );
275
276         pthread_mutex_lock( qry->mutexBusy );
277         value = qry->busyFlag;
278         pthread_mutex_unlock( qry->mutexBusy );
279         return value;
280 }
281
282 /**
283  * Set query aged flag.
284  * \param qry Query object.
285  * \param value Value of aged flag.
286  */
287 static void ldapqry_set_aged_flag( LdapQuery *qry, const gboolean value ) {
288         g_return_if_fail( qry != NULL );
289         qry->agedFlag = value;
290 }
291
292 /**
293  * Clear LDAP query member variables.
294  * \param qry Query object.
295  */
296 static void ldapqry_clear( LdapQuery *qry ) {
297         g_return_if_fail( qry != NULL );
298
299         /* Free internal stuff */
300         g_free( ADDRQUERY_NAME(qry) );
301         g_free( ADDRQUERY_SEARCHVALUE(qry) );
302
303         /* Clear pointers and value */
304         ADDRQUERY_NAME(qry) = NULL;
305         ADDRQUERY_SEARCHVALUE(qry) = NULL;
306         ADDRQUERY_ID(qry) = 0;
307         ADDRQUERY_SEARCHTYPE(qry) = ADDRSEARCH_NONE;
308         ADDRQUERY_RETVAL(qry) = LDAPRC_SUCCESS;
309         qry->entriesRead = 0;
310         qry->elapsedTime = 0;
311         qry->stopFlag = FALSE;
312         qry->busyFlag = FALSE;
313         qry->agedFlag = FALSE;
314         qry->completed = FALSE;
315         qry->callBackEntry = NULL;
316         qry->callBackEnd = NULL;
317         qry->ldap = NULL;
318         qry->data = NULL;
319 }
320
321 /**
322  * Free up LDAP query object by releasing internal memory. Note that
323  * the thread object will be freed by the OS.
324  * \param qry Query object to process.
325  */
326 void ldapqry_free( LdapQuery *qry ) {
327         g_return_if_fail( qry != NULL );
328
329         /* Clear out internal members */
330         ADDRQUERY_TYPE(qry) = ADDRQUERY_NONE;
331         ldapqry_clear( qry );
332
333         /* Free the mutex */
334         pthread_mutex_destroy( qry->mutexStop );
335         pthread_mutex_destroy( qry->mutexBusy );
336         pthread_mutex_destroy( qry->mutexEntry );
337         g_free( qry->mutexStop );
338         g_free( qry->mutexBusy );
339         g_free( qry->mutexEntry );
340         qry->mutexEntry = NULL;
341         qry->mutexBusy = NULL;
342         qry->mutexStop = NULL;
343
344         /* Do not free folder - parent server object should free */     
345         ADDRQUERY_FOLDER(qry) = NULL;
346
347         /* Do not free thread - thread should be terminated before freeing */
348         qry->thread = NULL;
349
350         /* Do not free LDAP control - should be destroyed before freeing */
351         qry->control = NULL;
352
353         /* Now release object */
354         g_free( qry );
355 }
356
357 /**
358  * Free linked lists of character strings.
359  * \param listName  List of common names.
360  * \param listAddr  List of addresses.
361  * \param listFirst List of first names.
362  * \param listLast  List of last names.
363  */
364 static void ldapqry_free_lists(
365                 GSList *listName, GSList *listAddr, GSList *listFirst,
366                 GSList *listLast, GSList *listDisplay, GSList *other_attrs )
367 {
368         GSList *cur = other_attrs;
369         mgu_free_list( listName );
370         mgu_free_list( listAddr );
371         mgu_free_list( listFirst );
372         mgu_free_list( listLast );
373         mgu_free_list( listDisplay );
374         for(;cur; cur = cur->next)
375                 addritem_free_attribute((UserAttribute *)cur->data);
376         g_slist_free(other_attrs);
377 }
378
379 /**
380  * Add all LDAP attribute values to a list.
381  * \param ld LDAP handle.
382  * \param entry LDAP entry to process.
383  * \param attr  LDAP attribute.
384  * \return List of values.
385  */
386 static GSList *ldapqry_add_list_values(
387                 LDAP *ld, LDAPMessage *entry, char *attr )
388 {
389         GSList *list = NULL;
390         gint i;
391         struct berval **vals;
392
393         if( ( vals = ldap_get_values_len( ld, entry, attr ) ) != NULL ) {
394                 for( i = 0; vals[i] != NULL; i++ ) {
395                         /*debug_print("lv\t%s: %s\n", attr?attr:"null",
396                                         vals[i]->bv_val?vals[i]->bv_val:"null");*/
397                         list = g_slist_append( list, g_strndup( vals[i]->bv_val, vals[i]->bv_len) );
398                 }
399         }
400         ldap_value_free_len( vals );
401         return list;
402 }
403
404 /**
405  * Add a single attribute value to a list.
406  * \param  ld    LDAP handle.
407  * \param  entry LDAP entry to process.
408  * \param  attr  LDAP attribute name to process.
409  * \return List of values; only one value will be present.
410  */
411 static GSList *ldapqry_add_single_value( LDAP *ld, LDAPMessage *entry, char *attr ) {
412         GSList *list = NULL;
413         struct berval **vals;
414
415         if( ( vals = ldap_get_values_len( ld, entry, attr ) ) != NULL ) {
416                 if( vals[0] != NULL ) {
417                         debug_print("sv\t%s: %s\n", attr?attr:"null",
418                                         vals[0]->bv_val?vals[0]->bv_val:"null");
419                         list = g_slist_append( list, g_strndup( vals[0]->bv_val, vals[0]->bv_len ));
420                 }
421         }
422         ldap_value_free_len( vals );
423         return list;
424 }
425
426 /**
427  * Build an address list entry and append to list of address items. Name is formatted
428  * as "<first-name> <last-name>".
429  *
430  * \param  cache     Address cache to load.
431  * \param  qry Query object to process.
432  * \param  dn        DN for entry found on server.
433  * \param  listName  List of common names for entry; see notes below.
434  * \param  listAddr  List of EMail addresses for entry.
435  * \param  listFirst List of first names for entry.
436  * \param  listLast  List of last names for entry.
437  *
438  * \return List of ItemEMail objects.
439  *
440  * Notes:
441  * 1) Each LDAP server entry may have multiple LDAP attributes with the same
442  *    name. For example, a single entry for a person may have more than one
443  *    common name, email address, etc.
444 *
445  * 2) The DN for the entry is unique for the server.
446  */
447 static GList *ldapqry_build_items_fl(
448                 AddressCache *cache, LdapQuery *qry, gchar *dn,
449                 GSList *listName, GSList *listAddr, GSList *listFirst,
450                 GSList *listLast, GSList *listDisplay, GSList *attributes )
451 {
452         GSList *nodeAddress, *cur;
453         gchar *firstName = NULL, *lastName = NULL, *fullName = NULL;
454         gboolean allocated = FALSE;
455         ItemPerson *person;
456         ItemEMail *email;
457         ItemFolder *folder;
458         GList *listReturn = NULL;
459
460         folder = ADDRQUERY_FOLDER(qry);
461         if( folder == NULL ) return listReturn;
462         if( listAddr == NULL ) return listReturn;
463
464         if ( listDisplay ) {
465                 allocated = FALSE;
466                 fullName = listDisplay->data;
467         }
468
469         /* Find longest first name in list */
470         firstName = mgu_slist_longest_entry( listFirst );
471
472         /* Format last name */
473         if( listLast ) {
474                 lastName = listLast->data;
475         }
476
477         if ( fullName == NULL ) {
478                 /* Find longest common name */
479                 allocated = FALSE;
480                 fullName = mgu_slist_longest_entry( listName );
481                 if( fullName == NULL ) {
482                         /* Format a full name from first and last names */
483                         if( firstName ) {
484                                 if( lastName ) {
485                                         fullName = g_strdup_printf( "%s %s", firstName, lastName );
486                                 }
487                                 else {
488                                         fullName = g_strdup_printf( "%s", firstName );
489                                 }
490                         }
491                         else {
492                                 if( lastName ) {
493                                         fullName = g_strdup_printf( "%s", lastName );
494                                 }
495                         }
496                         if( fullName ) {
497                                 g_strchug( fullName ); g_strchomp( fullName );
498                                 allocated = TRUE;
499                         }
500                 }
501         }
502
503         /* Add person into folder */            
504         person = addritem_create_item_person();
505         addritem_person_set_common_name( person, fullName );
506         addritem_person_set_first_name( person, firstName );
507         addritem_person_set_last_name( person, lastName );
508         addritem_person_set_nick_name( person, fullName );
509         addrcache_id_person( cache, person );
510         addritem_person_set_external_id( person, dn );
511         
512         for (cur = attributes; cur; cur = cur->next) {
513                 UserAttribute *attrib = addritem_copy_attribute((UserAttribute *)cur->data);
514                 addritem_person_add_attribute( person, attrib );
515         }
516         
517         addrcache_folder_add_person( cache, ADDRQUERY_FOLDER(qry), person );
518
519         qry->entriesRead++;
520
521         /* Add each address item */
522         nodeAddress = listAddr;
523         while( nodeAddress ) {
524                 email = addritem_create_item_email();
525                 addritem_email_set_address( email, nodeAddress->data );
526                 addrcache_id_email( cache, email );
527                 addrcache_person_add_email( cache, person, email );
528                 addritem_person_add_email( person, email );
529                 /*if (debug_get_mode()) {
530                         addritem_print_item_email(email, stdout);
531                 }*/
532                 listReturn = g_list_append( listReturn, email );
533                 nodeAddress = g_slist_next( nodeAddress );
534         }
535
536         /* Free any allocated memory */
537         if( allocated ) {
538                 g_free( fullName );
539         }
540         fullName = firstName = lastName = NULL;
541
542         return listReturn;
543 }
544
545 /**
546  * Process a single search entry.
547  * \param  cache Address cache to load.
548  * \param  qry   Query object to process.
549  * \param  ld    LDAP handle.
550  * \param  e     LDAP message.
551  * \return List of EMail objects found.
552  */
553 static GList *ldapqry_process_single_entry(
554                 AddressCache *cache, LdapQuery *qry, LDAP *ld, LDAPMessage *e )
555 {
556         char *dnEntry;
557         char *attribute;
558         LdapControl *ctl;
559         BerElement *ber;
560         GSList *listName = NULL, *listAddress = NULL;
561         GSList *listFirst = NULL, *listLast = NULL;
562         GSList *listDisplay = NULL;
563         GSList *other_attrs = NULL;
564         GList *listReturn;
565
566         listReturn = NULL;
567         ctl = qry->control;
568         dnEntry = ldap_get_dn( ld, e );
569         debug_print( "DN: %s\n", dnEntry?dnEntry:"null" );
570
571         /* Process all attributes */
572         for( attribute = ldap_first_attribute( ld, e, &ber ); attribute != NULL;
573                 attribute = ldap_next_attribute( ld, e, ber ) ) {
574                 if( strcasecmp( attribute, ctl->attribEMail ) == 0 ) {
575                         listAddress = ldapqry_add_list_values( ld, e, attribute );
576                 }
577                 else if( strcasecmp( attribute, ctl->attribCName ) == 0 ) {
578                         listName = ldapqry_add_list_values( ld, e, attribute );
579                 }
580                 else if( strcasecmp( attribute, ctl->attribFName ) == 0 ) {
581                         listFirst = ldapqry_add_list_values( ld, e, attribute );
582                 }
583                 else if( strcasecmp( attribute, ctl->attribLName ) == 0 ) {
584                         listLast = ldapqry_add_single_value( ld, e, attribute );
585                 } else if( strcasecmp( attribute, ctl->attribDName ) == 0 ) {
586                         listDisplay = ldapqry_add_single_value( ld, e, attribute );
587                 } else {
588                         GSList *attlist = ldapqry_add_single_value( ld, e, attribute );
589                         UserAttribute *attrib = addritem_create_attribute();
590                         const gchar *attvalue = attlist?((gchar *)attlist->data):NULL;
591                         if (attvalue) {
592                                 addritem_attrib_set_name( attrib, attribute );
593                                 addritem_attrib_set_value( attrib, attvalue );
594                                 other_attrs = g_slist_prepend(other_attrs, attrib);
595                         }
596                         mgu_free_list(attlist);
597                 }
598                 /* Free memory used to store attribute */
599                 ldap_memfree( attribute );
600         }
601
602         /* Format and add items to cache */
603         listReturn = ldapqry_build_items_fl(
604                 cache, qry, dnEntry, listName, listAddress, listFirst, listLast, listDisplay, other_attrs );
605
606         /* Free up */
607         ldapqry_free_lists( listName, listAddress, listFirst, listLast, listDisplay, other_attrs );
608         listName = listAddress = listFirst = listLast = listDisplay = other_attrs = NULL;
609
610         if( ber != NULL ) {
611                 ber_free( ber, 0 );
612         }
613         g_free( dnEntry );
614
615         return listReturn;
616 }
617
618 /**
619  * Check parameters that are required for a search. This should
620  * be called before performing a search.
621  * \param  qry Query object to process.
622  * \return <i>TRUE</i> if search criteria appear OK.
623  */
624 gboolean ldapqry_check_search( LdapQuery *qry ) {
625         LdapControl *ctl;
626         ADDRQUERY_RETVAL(qry) = LDAPRC_CRITERIA;
627
628         /* Test for control data */
629         ctl = qry->control;
630         if( ctl == NULL ) {
631                 return FALSE;
632         }
633
634         /* Test for search value */
635         if( ADDRQUERY_SEARCHVALUE(qry) == NULL ) {
636                 return FALSE;
637         }
638         if( strlen( ADDRQUERY_SEARCHVALUE(qry) ) < 1 ) {
639                 return FALSE;
640         }
641         ADDRQUERY_RETVAL(qry) = LDAPRC_SUCCESS;
642         return TRUE;
643 }
644
645 /**
646  * Touch the query. This nudges the touch time with the current time.
647  * \param qry Query object to process.
648  */
649 void ldapqry_touch( LdapQuery *qry ) {
650         qry->touchTime = time( NULL );
651         qry->agedFlag = FALSE;
652 }
653
654 /**
655  * Connect to LDAP server.
656  * \param  qry Query object to process.
657  * \return Error/status code.
658  */
659 static gint ldapqry_connect( LdapQuery *qry ) {
660         LdapControl *ctl;
661         LDAP *ld = NULL;
662         gint rc;
663         gint version;
664         gchar *uri = NULL;
665
666         /* Initialize connection */
667         if (debug_get_mode()) {
668                 debug_print("===ldapqry_connect===\n");
669                 /*ldapqry_print(qry, stdout);*/
670         }
671         ctl = qry->control;
672         /*if (debug_get_mode()) {
673                 ldapctl_print(ctl, stdout);
674                 debug_print("======\n");
675         }*/
676         ldapqry_touch( qry );
677         qry->startTime = qry->touchTime;
678         qry->elapsedTime = -1;
679         ADDRQUERY_RETVAL(qry) = LDAPRC_INIT;
680
681         ldapsrv_set_options (ctl->timeOut, NULL);
682
683         uri = g_strdup_printf("ldap%s://%s:%d",
684                                 ctl->enableSSL?"s":"",
685                                 ctl->hostName, ctl->port);
686         ldap_initialize(&ld, uri);
687         g_free(uri);
688
689         if (ld == NULL)
690                 return ADDRQUERY_RETVAL(qry);
691
692         qry->ldap = ld;
693         ADDRQUERY_RETVAL(qry) = LDAPRC_STOP_FLAG;
694         if( ldapqry_get_stop_flag( qry ) ) {
695                 return ADDRQUERY_RETVAL(qry);
696         }
697         ldapqry_touch( qry );
698
699         debug_print("connected to LDAP host %s on port %d\n",
700                         ctl->hostName?ctl->hostName:"null", ctl->port);
701
702 #ifdef USE_LDAP_TLS
703         /* Handle TLS */
704         version = LDAP_VERSION3;
705         rc = ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION, &version );
706         if( rc == LDAP_OPT_SUCCESS ) {
707                 ctl->version = LDAP_VERSION3;
708         }
709
710         if( ctl->version == LDAP_VERSION3 ) {
711                 if( ctl->enableTLS && !ctl->enableSSL ) {
712                         ADDRQUERY_RETVAL(qry) = LDAPRC_TLS;
713                         rc = ldap_start_tls_s( ld, NULL, NULL );
714                         
715                         debug_print("rc=%d\n", rc);
716                         debug_print("LDAP Status: set_option: %s\n", ldap_err2string(rc));
717
718                         if( rc != LDAP_SUCCESS ) {
719                                 return ADDRQUERY_RETVAL(qry);
720                         }
721                 }
722         }
723 #endif
724
725         /* Bind to the server, if required */
726         ADDRQUERY_RETVAL(qry) = LDAPRC_BIND;
727         if( ctl->bindDN ) {
728                 if( * ctl->bindDN != '\0' ) {
729                         debug_print("binding...\n");
730                         rc = claws_ldap_simple_bind_s( ld, ctl->bindDN, ctl->bindPass );
731                         debug_print("rc=%d\n", rc);
732                         if( rc != LDAP_SUCCESS ) {
733                                 debug_print("LDAP Error: ldap_simple_bind_s: %s\n",     ldap_err2string(rc));
734                                 return ADDRQUERY_RETVAL(qry);
735                         }
736                 }
737         }
738         ADDRQUERY_RETVAL(qry) = LDAPRC_STOP_FLAG;
739         if( ldapqry_get_stop_flag( qry ) ) {
740                 return ADDRQUERY_RETVAL(qry);
741         }
742         ldapqry_touch( qry );
743
744         ADDRQUERY_RETVAL(qry) = LDAP_SUCCESS;
745
746         return ADDRQUERY_RETVAL(qry);
747 }
748
749 /**
750  * Connect to LDAP server.
751  * \param  qry Query object to process.
752  * \return Error/status code.
753  */
754 static gint ldapqry_disconnect( LdapQuery *qry ) {
755         /* Disconnect */
756         if( qry->ldap ) ldap_unbind_ext( qry->ldap, NULL, NULL );
757         qry->ldap = NULL;
758
759         ldapqry_touch( qry );
760         qry->elapsedTime = qry->touchTime - qry->startTime;
761
762         return ADDRQUERY_RETVAL(qry);
763 }
764
765 /**
766  * Perform the LDAP search, reading LDAP entries into cache.
767  * Note that one LDAP entry can have multiple values for many of its
768  * attributes. If these attributes are E-Mail addresses; these are
769  * broken out into separate address items. For any other attribute,
770  * only the first occurrence is read.
771  * 
772  * \param  qry Query object to process.
773  * \return Error/status code.
774  */
775 static gint ldapqry_search_retrieve( LdapQuery *qry ) {
776         LdapControl *ctl;
777         LDAP *ld;
778         LDAPMessage *result, *e = NULL;
779         char **attribs;
780         gchar *criteria;
781         gboolean searchFlag;
782         gboolean entriesFound;
783         gboolean first;
784         struct timeval timeout;
785         gint rc;
786         AddressCache *cache;
787         GList *listEMail;
788
789         /* Initialize some variables */
790         ld = qry->ldap;
791         ctl = qry->control;
792         cache = qry->server->addressCache;
793         timeout.tv_sec = ctl->timeOut;
794         timeout.tv_usec = 0L;
795         entriesFound = FALSE;
796         ADDRQUERY_RETVAL(qry) = LDAPRC_SUCCESS;
797
798         /* Define all attributes we are interested in. */
799         attribs = ldapctl_full_attribute_array( ctl );
800
801         /* Create LDAP search string */
802         criteria = ldapctl_format_criteria( ctl, ADDRQUERY_SEARCHVALUE(qry) );
803         debug_print("Search criteria ::%s::\n", criteria?criteria:"null");
804
805         /*
806          * Execute the search - this step may take some time to complete
807          * depending on network traffic and server response time.
808          */
809         ADDRQUERY_RETVAL(qry) = LDAPRC_TIMEOUT;
810         rc = ldap_search_ext_s( ld, ctl->baseDN, LDAP_SCOPE_SUBTREE, criteria,
811                 attribs, 0, NULL, NULL, &timeout, 0, &result );
812         debug_print("LDAP Error: ldap_search_st: %d\n", rc);
813         debug_print("LDAP Error: ldap_search_st: %s\n", ldap_err2string(rc));
814         ldapctl_free_attribute_array( attribs );
815         g_free( criteria );
816         criteria = NULL;
817         if( rc == LDAP_TIMEOUT ) {
818                 return ADDRQUERY_RETVAL(qry);
819         }
820         ADDRQUERY_RETVAL(qry) = LDAPRC_SEARCH;
821
822         /* Test valid returns */
823         searchFlag = FALSE;
824         if( rc == LDAP_ADMINLIMIT_EXCEEDED ) {
825                 searchFlag = TRUE;
826         }
827         else if( rc == LDAP_SUCCESS ) {
828                 searchFlag = TRUE;
829         }
830         else if( rc == LDAP_PARTIAL_RESULTS ) {
831                 searchFlag = TRUE;
832         }
833         else {
834                 debug_print("LDAP Error: ldap_search_st: %d\n", rc);
835                 debug_print("LDAP Error: ldap_search_st: %s\n", ldap_err2string(rc));
836                 return ADDRQUERY_RETVAL(qry);
837         }
838         ADDRQUERY_RETVAL(qry) = LDAPRC_STOP_FLAG;
839
840         debug_print("Total results are: %d\n", ldap_count_entries(ld, result));
841
842         /* Process results */
843         first = TRUE;
844         while( searchFlag ) {
845                 ldapqry_touch( qry );
846                 if( qry->entriesRead >= ctl->maxEntries ) break;                
847
848                 /* Test for stop */             
849                 if( ldapqry_get_stop_flag( qry ) ) {
850                         break;
851                 }
852
853                 /* Retrieve entry */            
854                 if( first ) {
855                         first = FALSE;
856                         e = ldap_first_entry( ld, result );
857                 }
858                 else {
859                         e = ldap_next_entry( ld, e );
860                 }
861                 if( e == NULL ) break;
862                 entriesFound = TRUE;
863
864                 /* Setup a critical section here */
865                 pthread_mutex_lock( qry->mutexEntry );
866
867                 /* Process entry */
868                 listEMail = ldapqry_process_single_entry( cache, qry, ld, e );
869
870                 /* Process callback */
871                 if( qry->callBackEntry ) {
872                         qry->callBackEntry( qry, ADDRQUERY_ID(qry), listEMail, qry->data );
873                 }
874                 else {
875                         /*if (debug_get_mode()) {
876                                 GList *node = listEMail;
877                                 while (node) {
878                                         addritem_print_item_email(node->data, stdout);
879                                         node = g_list_next(node);
880                                 }
881                         }*/
882                         g_list_free( listEMail );
883                 }
884                 pthread_mutex_unlock( qry->mutexEntry );
885         }
886
887         /* Free up and disconnect */
888         ldap_msgfree( result );
889
890         if( searchFlag ) {
891                 if( entriesFound ) {
892                         ADDRQUERY_RETVAL(qry) = LDAPRC_SUCCESS;
893                 }
894                 else {
895                         ADDRQUERY_RETVAL(qry) = LDAPRC_NOENTRIES;
896                 }
897         }
898
899         return ADDRQUERY_RETVAL(qry);
900 }
901
902 /**
903  * Connection, perform search and disconnect.
904  * \param  qry Query object to process.
905  * \return Error/status code.
906  */
907 static gint ldapqry_perform_search( LdapQuery *qry ) {
908         /* Check search criteria */     
909         if( ! ldapqry_check_search( qry ) ) {
910                 return ADDRQUERY_RETVAL(qry);
911         }
912
913         /* Connect */
914         qry->ldap = NULL;
915         ldapqry_connect( qry );
916         if( ADDRQUERY_RETVAL(qry) == LDAPRC_SUCCESS ) {
917                 /* Perform search */
918                 ldapqry_search_retrieve( qry );
919         }
920         /* Disconnect */
921         ldapqry_disconnect( qry );
922         qry->ldap = NULL;
923
924         return ADDRQUERY_RETVAL(qry);
925 }
926
927 static gint ldapqry_perform_locate( LdapQuery *qry );
928
929 /**
930  * Wrapper around search.
931  * \param  qry Query object to process.
932  * \return Error/status code.
933  */
934 static gint ldapqry_search( LdapQuery *qry ) {
935         gint retVal;
936
937         g_return_val_if_fail( qry != NULL, -1 );
938         g_return_val_if_fail( qry->control != NULL, -1 );
939
940         ldapqry_touch( qry );
941         qry->completed = FALSE;
942
943         /* Setup pointer to thread specific area */
944         pthread_setspecific( _queryThreadKey_, qry );
945
946         pthread_detach( pthread_self() );
947         
948         /* Now perform the search */
949         qry->entriesRead = 0;
950         ADDRQUERY_RETVAL(qry) = LDAPRC_SUCCESS;
951         ldapqry_set_busy_flag( qry, TRUE );
952         ldapqry_set_stop_flag( qry, FALSE );
953         if( ADDRQUERY_SEARCHTYPE(qry) == ADDRSEARCH_LOCATE ) {
954                 retVal = ldapqry_perform_locate( qry );
955         }
956         else {
957                 retVal = ldapqry_perform_search( qry );
958         }
959         if( retVal == LDAPRC_SUCCESS ) {
960                 qry->server->addressCache->dataRead = TRUE;
961                 qry->server->addressCache->accessFlag = FALSE;
962                 if( ldapqry_get_stop_flag( qry ) ) {
963                         debug_print("Search was terminated prematurely\n");
964                 }
965                 else {
966                         ldapqry_touch( qry );
967                         qry->completed = TRUE;
968                         debug_print("Search ran to completion\n");
969                 }
970         }
971         ldapqry_set_stop_flag( qry, TRUE );
972         ldapqry_set_busy_flag( qry, FALSE );
973
974         /* Process callback */  
975         if( qry->callBackEnd ) {
976                 g_timeout_add(0, callbackend, qry);
977         }
978
979         return ADDRQUERY_RETVAL(qry);
980 }
981
982 /**
983  * Read data into list using a background thread. Callback function will be
984  * notified when search is complete.
985  * \param  qry Query object to process.
986  * \return Error/status code.
987  */
988 gint ldapqry_read_data_th( LdapQuery *qry ) {
989         g_return_val_if_fail( qry != NULL, -1 );
990         g_return_val_if_fail( qry->control != NULL, -1 );
991
992         ldapqry_set_stop_flag( qry, FALSE );
993         ldapqry_touch( qry );
994         if( ldapqry_check_search( qry ) ) {
995                 if( ADDRQUERY_RETVAL(qry) == LDAPRC_SUCCESS ) {
996                         debug_print("Starting LDAP search thread\n");
997                         ldapqry_set_busy_flag( qry, TRUE );
998                         qry->thread = g_malloc0( sizeof( pthread_t ) );
999
1000                         /* Setup thread */                      
1001                         pthread_create( qry->thread, NULL,
1002                                 (void *) ldapqry_search, (void *) qry );
1003                 }
1004         }
1005         return ADDRQUERY_RETVAL(qry);
1006 }
1007
1008 /**
1009  * Cleanup LDAP thread data. This function will be called when each thread
1010  * exits. Note that the thread object will be freed by the kernel.
1011  * \param ptr Pointer to object being destroyed (a query object in this case).
1012  */
1013 static void ldapqry_destroyer( void * ptr ) {
1014         LdapQuery *qry;
1015
1016         qry = ( LdapQuery * ) ptr;
1017         g_return_if_fail( qry != NULL );
1018
1019         debug_print("ldapqry_destroyer::%d::%s\n", (int) pthread_self(),
1020                         ADDRQUERY_NAME(qry)?ADDRQUERY_NAME(qry):"null");
1021
1022         /* Perform any destruction here */
1023         if( qry->control != NULL ) {
1024                 ldapctl_free( qry->control );
1025         }
1026         qry->control = NULL;
1027         qry->thread = NULL;
1028         ldapqry_set_busy_flag( qry, FALSE );
1029 }
1030
1031 /**
1032  * Cancel thread associated with query.
1033  * \param qry Query object to process.
1034  */
1035 void ldapqry_cancel( LdapQuery *qry ) {
1036         g_return_if_fail( qry != NULL );
1037
1038         debug_print("cancelling::%d::%s\n", (int) pthread_self(), ADDRQUERY_NAME(qry));
1039         if( ldapqry_get_busy_flag( qry ) ) {
1040                 if( qry->thread ) {
1041                         debug_print("calling pthread_cancel\n");
1042                         pthread_cancel( * qry->thread );
1043                 }
1044         }
1045 }
1046
1047 /**
1048  * Initialize LDAP query. This function should be called once before executing
1049  * any LDAP queries to initialize thread specific data.
1050  */
1051 void ldapqry_initialize( void ) {
1052         debug_print("ldapqry_initialize...\n");
1053         if( ! _queryThreadInit_ ) {
1054                 debug_print("ldapqry_initialize::creating thread specific area\n");
1055                 pthread_key_create( &_queryThreadKey_, ldapqry_destroyer );
1056                 _queryThreadInit_ = TRUE;
1057         }
1058         debug_print("ldapqry_initialize... done!\n");
1059 }
1060
1061 /**
1062  * Age the query based on LDAP control parameters.
1063  * \param qry    Query object to process.
1064  * \param maxAge Maximum age of query (in seconds).
1065  */
1066 void ldapqry_age( LdapQuery *qry, gint maxAge ) {
1067         gint age;
1068
1069         g_return_if_fail( qry != NULL );
1070
1071         /* Limit the time that queries can hang around */       
1072         if( maxAge < 1 ) maxAge = LDAPCTL_MAX_QUERY_AGE;
1073
1074         /* Check age of query */
1075         age = time( NULL ) - qry->touchTime;
1076         if( age > maxAge ) {
1077                 qry->agedFlag = TRUE;
1078         }
1079 }
1080
1081 /**
1082  * Delete folder associated with query results.
1083  * \param qry Query object to process.
1084  */
1085 void ldapqry_delete_folder( LdapQuery *qry ) {
1086         AddressCache *cache;
1087         ItemFolder *folder;
1088
1089         g_return_if_fail( qry != NULL );
1090
1091         folder = ADDRQUERY_FOLDER(qry);
1092         if( folder ) {
1093                 cache = qry->server->addressCache;
1094                 folder = addrcache_remove_folder_delete( cache, folder );
1095                 if( folder ) {
1096                         addritem_free_item_folder( folder );
1097                 }
1098                 ADDRQUERY_FOLDER(qry) = NULL;
1099         }
1100 }
1101
1102 /**
1103  * Create a name/value pair object.
1104  * \param n Name.
1105  * \param v Value.
1106  * \return Initialized object.
1107  */
1108 static NameValuePair *ldapqry_create_name_value( const gchar *n, const gchar *v ) {
1109         NameValuePair *nvp = g_new0( NameValuePair, 1 );
1110
1111         nvp->name = g_strdup( n );
1112         nvp->value = g_strdup( v );
1113         return nvp;
1114 }
1115
1116 /**
1117  * Free up name/value pair object.
1118  * \param nvp Name/value object.
1119  */
1120 void ldapqry_free_name_value( NameValuePair *nvp ) {
1121         if( nvp ) {
1122                 g_free( nvp->name );
1123                 g_free( nvp->value );
1124                 nvp->name = nvp->value = NULL;
1125                 g_free( nvp );
1126         }
1127 }
1128
1129 /**
1130  * Free up a list name/value pair objects.
1131  * \param list List of name/value objects.
1132  */
1133 void ldapqry_free_list_name_value( GList *list ) {
1134         GList *node;
1135
1136         node = list;
1137         while( node ) {
1138                 NameValuePair *nvp = ( NameValuePair * ) node->data;
1139                 ldapqry_free_name_value( nvp );
1140                 node->data = NULL;
1141                 node = g_list_next( node );
1142         }
1143         g_list_free( list );
1144 }
1145
1146 /**
1147  * Load a list of name/value pairs from LDAP attributes.
1148  * \param  ld          LDAP handle.
1149  * \param  e          LDAP message.
1150  * \param  attr       Attribute name.
1151  * \param  listValues List to populate.
1152  * \return List of attribute name/value pairs.
1153  */
1154 static GList *ldapqry_load_attrib_values(
1155                 LDAP *ld, LDAPMessage *entry, char *attr,
1156                 GList *listValues )
1157 {
1158         GList *list = NULL;
1159         gint i;
1160         struct berval **vals;
1161         NameValuePair *nvp;
1162
1163         list = listValues;
1164         if( ( vals = ldap_get_values_len( ld, entry, attr ) ) != NULL ) {
1165                 for( i = 0; vals[i] != NULL; i++ ) {
1166                         gchar *tmp = g_strndup( vals[i]->bv_val, vals[i]->bv_len);
1167                         nvp = ldapqry_create_name_value( attr, tmp );
1168                         g_free(tmp);
1169                         list = g_list_append( list, nvp );
1170                 }
1171         }
1172         ldap_value_free_len( vals );
1173         return list;
1174 }
1175
1176 /**
1177  * Fetch a list of all attributes.
1178  * \param  ld    LDAP handle.
1179  * \param  e     LDAP message.
1180  * \return List of attribute name/value pairs.
1181  */
1182 static GList *ldapqry_fetch_attribs( LDAP *ld, LDAPMessage *e )
1183 {
1184         char *attribute;
1185         BerElement *ber;
1186         GList *listValues = NULL;
1187
1188         /* Process all attributes */
1189         for( attribute = ldap_first_attribute( ld, e, &ber ); attribute != NULL;
1190                 attribute = ldap_next_attribute( ld, e, ber ) ) {
1191                 listValues = ldapqry_load_attrib_values( ld, e, attribute, listValues );
1192                 ldap_memfree( attribute );
1193         }
1194
1195         /* Free up */
1196         if( ber != NULL ) {
1197                 ber_free( ber, 0 );
1198         }
1199         return listValues;
1200 }
1201
1202 #define CRITERIA_SINGLE "(objectclass=*)"
1203
1204 /**
1205  * Perform the data retrieval for a specific LDAP record.
1206  * 
1207  * \param  qry Query object to process.
1208  * \return Error/status code.
1209  */
1210 static gint ldapqry_locate_retrieve( LdapQuery *qry ) {
1211         LdapControl *ctl;
1212         LDAP *ld;
1213         LDAPMessage *result, *e = NULL;
1214         gboolean entriesFound;
1215         gboolean first;
1216         struct timeval timeout;
1217         gint rc;
1218         gchar *dn;
1219         GList *listValues;
1220
1221         /* Initialize some variables */
1222         ld = qry->ldap;
1223         ctl = qry->control;
1224         dn = ADDRQUERY_SEARCHVALUE(qry);
1225         timeout.tv_sec = ctl->timeOut;
1226         timeout.tv_usec = 0L;
1227         entriesFound = FALSE;
1228
1229         /*
1230          * Execute the search - this step may take some time to complete
1231          * depending on network traffic and server response time.
1232          */
1233         ADDRQUERY_RETVAL(qry) = LDAPRC_TIMEOUT;
1234         rc = ldap_search_ext_s( ld, dn, LDAP_SCOPE_BASE, CRITERIA_SINGLE,
1235                 NULL, 0, NULL, NULL, &timeout, 0, &result );
1236         if( rc == LDAP_TIMEOUT ) {
1237                 return ADDRQUERY_RETVAL(qry);
1238         }
1239         ADDRQUERY_RETVAL(qry) = LDAPRC_SEARCH;
1240         if( rc != LDAP_SUCCESS ) {
1241                 debug_print("LDAP Error: ldap_search_st: %s\n", ldap_err2string(rc));
1242                 return ADDRQUERY_RETVAL(qry);
1243         }
1244
1245         debug_print("Total results are: %d\n", ldap_count_entries(ld, result));
1246
1247         /* Process results */
1248         ADDRQUERY_RETVAL(qry) = LDAPRC_STOP_FLAG;
1249         first = TRUE;
1250         while( TRUE ) {
1251                 ldapqry_touch( qry );
1252                 if( qry->entriesRead >= ctl->maxEntries ) break;                
1253
1254                 /* Test for stop */
1255                 if( ldapqry_get_stop_flag( qry ) ) {
1256                         break;
1257                 }
1258
1259                 /* Retrieve entry */            
1260                 if( first ) {
1261                         first = FALSE;
1262                         e = ldap_first_entry( ld, result );
1263                 }
1264                 else {
1265                         e = ldap_next_entry( ld, e );
1266                 }
1267                 if( e == NULL ) break;
1268
1269                 entriesFound = TRUE;
1270
1271                 /* Setup a critical section here */
1272                 pthread_mutex_lock( qry->mutexEntry );
1273
1274                 /* Process entry */
1275                 listValues = ldapqry_fetch_attribs( ld, e );
1276
1277                 /* Process callback */
1278                 if( qry->callBackEntry ) {
1279                         qry->callBackEntry( qry, ADDRQUERY_ID(qry), listValues, qry->data );
1280                 }
1281                 ldapqry_free_list_name_value( listValues );
1282                 listValues = NULL;
1283
1284                 pthread_mutex_unlock( qry->mutexEntry );
1285         }
1286
1287         /* Free up and disconnect */
1288         ldap_msgfree( result );
1289
1290         if( entriesFound ) {
1291                 ADDRQUERY_RETVAL(qry) = LDAPRC_SUCCESS;
1292         }
1293         else {
1294                 ADDRQUERY_RETVAL(qry) = LDAPRC_NOENTRIES;
1295         }
1296
1297         return ADDRQUERY_RETVAL(qry);
1298 }
1299
1300 /**
1301  * Perform the search to locate a specific LDAP record identified by
1302  * distinguished name (dn).
1303  * 
1304  * \param  qry Query object to process.
1305  * \return Error/status code.
1306  */
1307 static gint ldapqry_perform_locate( LdapQuery *qry ) {
1308         /* Connect */
1309         qry->ldap = NULL;
1310         ldapqry_connect( qry );
1311         if( ADDRQUERY_RETVAL(qry) == LDAPRC_SUCCESS ) {
1312                 /* Perform search */
1313                 ldapqry_locate_retrieve( qry );
1314         }
1315         /* Disconnect */
1316         ldapqry_disconnect( qry );
1317         qry->ldap = NULL;
1318
1319         /* Process callback */  
1320         if( qry->callBackEnd ) {
1321                 g_timeout_add(0, callbackend, qry);
1322         }
1323
1324         return ADDRQUERY_RETVAL(qry);
1325 }
1326
1327 /**
1328  * Remove results (folder and data) for specified LDAP query.
1329  * \param  qry Query object to process.
1330  * \return TRUE if folder deleted successfully.
1331  */
1332 gboolean ldapquery_remove_results( LdapQuery *qry ) {
1333         gboolean retVal = FALSE;
1334
1335         ldapqry_set_aged_flag( qry, TRUE );
1336
1337         if( ldapqry_get_busy_flag( qry ) ) {
1338                 ldapqry_set_stop_flag( qry, TRUE );
1339         }
1340         else {
1341                 LdapServer *server = qry->server;
1342                 server->listQuery = g_list_remove(server->listQuery, qry);
1343
1344                 retVal = TRUE;
1345         }
1346         return retVal;
1347 }
1348
1349 void ldapqry_print(LdapQuery *qry, FILE *stream) {
1350         g_return_if_fail( qry != NULL );
1351
1352         ldapsvr_print_data(qry->server, stream);
1353         ldapctl_print(qry->control, stream);
1354         fprintf(stream, "entriesRead: %d\n", qry->entriesRead);
1355         fprintf(stream, "elapsedTime: %d\n", qry->elapsedTime);
1356         fprintf(stream, "stopFlag: %d\n", qry->stopFlag);
1357         fprintf(stream, "busyFlag: %d\n", qry->busyFlag);
1358         fprintf(stream, "agedFlag: %d\n", qry->agedFlag);
1359         fprintf(stream, "completed: %d\n", qry->completed);
1360         fprintf(stream, "startTime: %d\n", (int) qry->startTime);
1361         fprintf(stream, "touchTime: %d\n", (int) qry->touchTime);
1362         fprintf(stream, "data: %s\n", qry->data?(gchar *)qry->data:"null");
1363 }
1364
1365 #endif  /* USE_LDAP */
1366
1367 /*
1368  * End of Source.
1369  */
1370
1371