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