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