src/syldap.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2001 Match Grun
   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Functions necessary to access LDAP servers.
  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 <ldap.h>
  34 #include <lber.h>
  35 #include <pthread.h>
  36 #include <dlfcn.h>
  37
  38 #include "mgutils.h"
  39 #include "addritem.h"
  40 #include "addrcache.h"
  41 #include "syldap.h"
  42 #include "utils.h"
  43
  44 /*
  45 * Create new LDAP server interface object.
  46 */
  47 SyldapServer *syldap_create() {
  48         SyldapServer *ldapServer;
  49
  50         debug_print("Creating LDAP server interface object\n");
  51
  52         ldapServer = g_new0( SyldapServer, 1 );
  53         ldapServer->name = NULL;
  54         ldapServer->hostName = NULL;
  55         ldapServer->port = SYLDAP_DFL_PORT;
  56         ldapServer->baseDN = NULL;
  57         ldapServer->bindDN = NULL;
  58         ldapServer->bindPass = NULL;
  59         ldapServer->searchCriteria = NULL;
  60         ldapServer->searchValue = NULL;
  61         ldapServer->entriesRead = 0;
  62         ldapServer->maxEntries = SYLDAP_MAX_ENTRIES;
  63         ldapServer->timeOut = SYLDAP_DFL_TIMEOUT;
  64         ldapServer->newSearch = TRUE;
  65         ldapServer->addressCache = addrcache_create();
  66         ldapServer->thread = NULL;
  67         ldapServer->busyFlag = FALSE;
  68         ldapServer->retVal = MGU_SUCCESS;
  69         ldapServer->callBack = NULL;
  70         ldapServer->accessFlag = FALSE;
  71         return ldapServer;
  72 }
  73
  74 /*
  75 * Specify name to be used.
  76 */
  77 void syldap_set_name( SyldapServer* ldapServer, const gchar *value ) {
  78         ldapServer->name = mgu_replace_string( ldapServer->name, value );
  79         g_strstrip( ldapServer->name );
  80 }
  81
  82 /*
  83 * Specify hostname to be used.
  84 */
  85 void syldap_set_host( SyldapServer* ldapServer, const gchar *value ) {
  86         addrcache_refresh( ldapServer->addressCache );
  87         ldapServer->hostName = mgu_replace_string( ldapServer->hostName, value );
  88         g_strstrip( ldapServer->hostName );
  89 }
  90
  91 /*
  92 * Specify port to be used.
  93 */
  94 void syldap_set_port( SyldapServer* ldapServer, const gint value ) {
  95         addrcache_refresh( ldapServer->addressCache );
  96         if( value > 0 ) {
  97                 ldapServer->port = value;
  98         }
  99         else {
 100                 ldapServer->port = SYLDAP_DFL_PORT;
 101         }
 102 }
 103
 104 /*
 105 * Specify base DN to be used.
 106 */
 107 void syldap_set_base_dn( SyldapServer* ldapServer, const gchar *value ) {
 108         addrcache_refresh( ldapServer->addressCache );
 109         ldapServer->baseDN = mgu_replace_string( ldapServer->baseDN, value );
 110         g_strstrip( ldapServer->baseDN );
 111 }
 112
 113 /*
 114 * Specify bind DN to be used.
 115 */
 116 void syldap_set_bind_dn( SyldapServer* ldapServer, const gchar *value ) {
 117         addrcache_refresh( ldapServer->addressCache );
 118         ldapServer->bindDN = mgu_replace_string( ldapServer->bindDN, value );
 119         g_strstrip( ldapServer->bindDN );
 120 }
 121
 122 /*
 123 * Specify bind password to be used.
 124 */
 125 void syldap_set_bind_password( SyldapServer* ldapServer, const gchar *value ) {
 126         addrcache_refresh( ldapServer->addressCache );
 127         ldapServer->bindPass = mgu_replace_string( ldapServer->bindPass, value );
 128         g_strstrip( ldapServer->bindPass );
 129 }
 130
 131 /*
 132 * Specify search criteria to be used.
 133 */
 134 void syldap_set_search_criteria( SyldapServer* ldapServer, const gchar *value ) {
 135         addrcache_refresh( ldapServer->addressCache );
 136         ldapServer->searchCriteria = mgu_replace_string( ldapServer->searchCriteria, value );
 137         g_strstrip( ldapServer->searchCriteria );
 138         ldapServer->newSearch = TRUE;
 139 }
 140
 141 /*
 142 * Specify search value to be searched for.
 143 */
 144 void syldap_set_search_value( SyldapServer* ldapServer, const gchar *value ) {
 145         addrcache_refresh( ldapServer->addressCache );
 146         ldapServer->searchValue = mgu_replace_string( ldapServer->searchValue, value );
 147         g_strstrip( ldapServer->searchValue );
 148         ldapServer->newSearch = TRUE;
 149 }
 150
 151 /*
 152 * Specify maximum number of entries to retrieve.
 153 */
 154 void syldap_set_max_entries( SyldapServer* ldapServer, const gint value ) {
 155         addrcache_refresh( ldapServer->addressCache );
 156         if( value > 0 ) {
 157                 ldapServer->maxEntries = value;
 158         }
 159         else {
 160                 ldapServer->maxEntries = SYLDAP_MAX_ENTRIES;
 161         }
 162 }
 163
 164 /*
 165 * Specify timeout value for LDAP operation (in seconds).
 166 */
 167 void syldap_set_timeout( SyldapServer* ldapServer, const gint value ) {
 168         addrcache_refresh( ldapServer->addressCache );
 169         if( value > 0 ) {
 170                 ldapServer->timeOut = value;
 171         }
 172         else {
 173                 ldapServer->timeOut = SYLDAP_DFL_TIMEOUT;
 174         }
 175 }
 176
 177 /*
 178 * Register a callback function. When called, the function will be passed
 179 * this object as an argument.
 180 */
 181 void syldap_set_callback( SyldapServer *ldapServer, void *func ) {
 182         ldapServer->callBack = func;
 183 }
 184
 185 void syldap_set_accessed( SyldapServer *ldapServer, const gboolean value ) {
 186         g_return_if_fail( ldapServer != NULL );
 187         ldapServer->accessFlag = value;
 188 }
 189
 190 /*
 191 * Refresh internal variables to force a file read.
 192 */
 193 void syldap_force_refresh( SyldapServer *ldapServer ) {
 194         addrcache_refresh( ldapServer->addressCache );
 195         ldapServer->newSearch = TRUE;
 196 }
 197
 198 gint syldap_get_status( SyldapServer *ldapServer ) {
 199         g_return_val_if_fail( ldapServer != NULL, -1 );
 200         return ldapServer->retVal;
 201 }
 202
 203 ItemFolder *syldap_get_root_folder( SyldapServer *ldapServer ) {
 204         g_return_val_if_fail( ldapServer != NULL, NULL );
 205         return addrcache_get_root_folder( ldapServer->addressCache );
 206 }
 207
 208 gchar *syldap_get_name( SyldapServer *ldapServer ) {
 209         g_return_val_if_fail( ldapServer != NULL, NULL );
 210         return ldapServer->name;
 211 }
 212
 213 gboolean syldap_get_accessed( SyldapServer *ldapServer ) {
 214         g_return_val_if_fail( ldapServer != NULL, FALSE );
 215         return ldapServer->accessFlag;
 216 }
 217
 218 /*
 219 * Free up LDAP server interface object by releasing internal memory.
 220 */
 221 void syldap_free( SyldapServer *ldapServer ) {
 222         g_return_if_fail( ldapServer != NULL );
 223
 224         debug_print("Freeing LDAP server interface object\n");
 225
 226         ldapServer->callBack = NULL;
 227
 228         /* Free internal stuff */
 229         g_free( ldapServer->name );
 230         g_free( ldapServer->hostName );
 231         g_free( ldapServer->baseDN );
 232         g_free( ldapServer->bindDN );
 233         g_free( ldapServer->bindPass );
 234         g_free( ldapServer->searchCriteria );
 235         g_free( ldapServer->searchValue );
 236
 237         ldapServer->port = 0;
 238         ldapServer->entriesRead = 0;
 239         ldapServer->maxEntries = 0;
 240         ldapServer->newSearch = FALSE;
 241
 242         /* Clear cache */
 243         addrcache_clear( ldapServer->addressCache );
 244         addrcache_free( ldapServer->addressCache );
 245
 246         /* Clear pointers */
 247         ldapServer->name = NULL;
 248         ldapServer->hostName = NULL;
 249         ldapServer->baseDN = NULL;
 250         ldapServer->bindDN = NULL;
 251         ldapServer->bindPass = NULL;
 252         ldapServer->searchCriteria = NULL;
 253         ldapServer->searchValue = NULL;
 254         ldapServer->addressCache = NULL;
 255         g_free(ldapServer->thread);
 256         ldapServer->thread = NULL;
 257         ldapServer->busyFlag = FALSE;
 258         ldapServer->retVal = MGU_SUCCESS;
 259         ldapServer->accessFlag = FALSE;
 260
 261         /* Now release LDAP object */
 262         g_free( ldapServer );
 263
 264 }
 265
 266 /*
 267 * Display object to specified stream.
 268 */
 269 void syldap_print_data( SyldapServer *ldapServer, FILE *stream ) {
 270         g_return_if_fail( ldapServer != NULL );
 271
 272         fprintf( stream, "SyldapServer:\n" );
 273         fprintf( stream, "     name: '%s'\n", ldapServer->name );
 274         fprintf( stream, "host name: '%s'\n", ldapServer->hostName );
 275         fprintf( stream, "     port: %d\n",   ldapServer->port );
 276         fprintf( stream, "  base dn: '%s'\n", ldapServer->baseDN );
 277         fprintf( stream, "  bind dn: '%s'\n", ldapServer->bindDN );
 278         fprintf( stream, "bind pass: '%s'\n", ldapServer->bindPass );
 279         fprintf( stream, " criteria: '%s'\n", ldapServer->searchCriteria );
 280         fprintf( stream, "searchval: '%s'\n", ldapServer->searchValue );
 281         fprintf( stream, "max entry: %d\n",   ldapServer->maxEntries );
 282         fprintf( stream, " num read: %d\n",   ldapServer->entriesRead );
 283         fprintf( stream, "  ret val: %d\n",   ldapServer->retVal );
 284         addrcache_print( ldapServer->addressCache, stream );
 285         addritem_print_item_folder( ldapServer->addressCache->rootFolder, stream );
 286 }
 287
 288 /*
 289 * Display object to specified stream.
 290 */
 291 void syldap_print_short( SyldapServer *ldapServer, FILE *stream ) {
 292         g_return_if_fail( ldapServer != NULL );
 293
 294         fprintf( stream, "SyldapServer:\n" );
 295         fprintf( stream, "     name: '%s'\n", ldapServer->name );
 296         fprintf( stream, "host name: '%s'\n", ldapServer->hostName );
 297         fprintf( stream, "     port: %d\n",   ldapServer->port );
 298         fprintf( stream, "  base dn: '%s'\n", ldapServer->baseDN );
 299         fprintf( stream, "  bind dn: '%s'\n", ldapServer->bindDN );
 300         fprintf( stream, "bind pass: '%s'\n", ldapServer->bindPass );
 301         fprintf( stream, " criteria: '%s'\n", ldapServer->searchCriteria );
 302         fprintf( stream, "searchval: '%s'\n", ldapServer->searchValue );
 303         fprintf( stream, "max entry: %d\n",   ldapServer->maxEntries );
 304         fprintf( stream, " num read: %d\n",   ldapServer->entriesRead );
 305         fprintf( stream, "  ret val: %d\n",   ldapServer->retVal );
 306 }
 307
 308 /*
 309 * Build an address list entry and append to list of address items. Name is formatted
 310 * as it appears in the common name (cn) attribute.
 311 */
 312 static void syldap_build_items_cn( SyldapServer *ldapServer, GSList *listName, GSList *listAddr ) {
 313         ItemPerson *person;
 314         ItemEMail *email;
 315         GSList *nodeName = listName;
 316
 317         while( nodeName ) {
 318                 GSList *nodeAddress = listAddr;
 319                 person = addritem_create_item_person();
 320                 addritem_person_set_common_name( person, nodeName->data );
 321                 addrcache_id_person( ldapServer->addressCache, person );
 322                 addrcache_add_person( ldapServer->addressCache, person );
 323
 324                 while( nodeAddress ) {
 325                         email = addritem_create_item_email();
 326                         addritem_email_set_address( email, nodeAddress->data );
 327                         addrcache_id_email( ldapServer->addressCache, email );
 328                         addrcache_person_add_email( ldapServer->addressCache, person, email );
 329                         nodeAddress = g_slist_next( nodeAddress );
 330                         ldapServer->entriesRead++;
 331                 }
 332                 nodeName = g_slist_next( nodeName );
 333         }
 334 }
 335
 336 /*
 337 * Build an address list entry and append to list of address items. Name is formatted
 338 * as "<first-name> <last-name>".
 339 */
 340 static void syldap_build_items_fl( SyldapServer *ldapServer, GSList *listAddr, GSList *listFirst, GSList *listLast  ) {
 341         GSList *nodeFirst = listFirst;
 342         GSList *nodeAddress = listAddr;
 343         gchar *firstName = NULL, *lastName = NULL, *fullName = NULL;
 344         gint iLen = 0, iLenT = 0;
 345         ItemPerson *person;
 346         ItemEMail *email;
 347
 348         /* Find longest first name in list */
 349         while( nodeFirst ) {
 350                 if( firstName == NULL ) {
 351                         firstName = nodeFirst->data;
 352                         iLen = strlen( firstName );
 353                 }
 354                 else {
 355                         if( ( iLenT = strlen( nodeFirst->data ) ) > iLen ) {
 356                                 firstName = nodeFirst->data;
 357                                 iLen = iLenT;
 358                         }
 359                 }
 360                 nodeFirst = g_slist_next( nodeFirst );
 361         }
 362
 363         /* Format name */
 364         if( listLast ) {
 365                 lastName = listLast->data;
 366         }
 367
 368         if( firstName ) {
 369                 if( lastName ) {
 370                         fullName = g_strdup_printf( "%s %s", firstName, lastName );
 371                 }
 372                 else {
 373                         fullName = g_strdup_printf( "%s", firstName );
 374                 }
 375         }
 376         else {
 377                 if( lastName ) {
 378                         fullName = g_strdup_printf( "%s", lastName );
 379                 }
 380         }
 381         if( fullName ) {
 382                 g_strchug( fullName ); g_strchomp( fullName );
 383         }
 384
 385         if( nodeAddress ) {
 386                 person = addritem_create_item_person();
 387                 addritem_person_set_common_name( person, fullName );
 388                 addritem_person_set_first_name( person, firstName );
 389                 addritem_person_set_last_name( person, lastName );
 390                 addrcache_id_person( ldapServer->addressCache, person );
 391                 addrcache_add_person( ldapServer->addressCache, person );
 392         }
 393
 394         /* Add address item */
 395         while( nodeAddress ) {
 396                 email = addritem_create_item_email();
 397                 addritem_email_set_address( email, nodeAddress->data );
 398                 addrcache_id_email( ldapServer->addressCache, email );
 399                 addrcache_person_add_email( ldapServer->addressCache, person, email );
 400                 nodeAddress = g_slist_next( nodeAddress );
 401                 ldapServer->entriesRead++;
 402         }
 403         g_free( fullName );
 404         fullName = firstName = lastName = NULL;
 405
 406 }
 407
 408 /*
 409 * Add all attribute values to a list.
 410 */
 411 static GSList *syldap_add_list_values( LDAP *ld, LDAPMessage *entry, char *attr ) {
 412         GSList *list = NULL;
 413         gint i;
 414         gchar **vals;
 415
 416         if( ( vals = ldap_get_values( ld, entry, attr ) ) != NULL ) {
 417                 for( i = 0; vals[i] != NULL; i++ ) {
 418                         /* printf( "lv\t%s: %s\n", attr, vals[i] ); */
 419                         list = g_slist_append( list, g_strdup( vals[i] ) );
 420                 }
 421         }
 422         ldap_value_free( vals );
 423         return list;
 424 }
 425
 426 /*
 427 * Add a single attribute value to a list.
 428 */
 429 static GSList *syldap_add_single_value( LDAP *ld, LDAPMessage *entry, char *attr ) {
 430         GSList *list = NULL;
 431         gchar **vals;
 432
 433         if( ( vals = ldap_get_values( ld, entry, attr ) ) != NULL ) {
 434                 if( vals[0] != NULL ) {
 435                         /* printf( "sv\t%s: %s\n", attr, vals[0] ); */
 436                         list = g_slist_append( list, g_strdup( vals[0] ) );
 437                 }
 438         }
 439         ldap_value_free( vals );
 440         return list;
 441 }
 442
 443 /*
 444 * Free linked lists of character strings.
 445 */
 446 static void syldap_free_lists( GSList *listName, GSList *listAddr, GSList *listID, GSList *listDN, GSList *listFirst, GSList *listLast ) {
 447         mgu_free_list( listName );
 448         mgu_free_list( listAddr );
 449         mgu_free_list( listID );
 450         mgu_free_list( listDN );
 451         mgu_free_list( listFirst );
 452         mgu_free_list( listLast );
 453 }
 454
 455 /*
 456 * Check parameters that are required for a search. This should
 457 * be called before performing a search.
 458 * Return: TRUE if search criteria appear OK.
 459 */
 460 gboolean syldap_check_search( SyldapServer *ldapServer ) {
 461         g_return_val_if_fail( ldapServer != NULL, FALSE );
 462
 463         ldapServer->retVal = MGU_LDAP_CRITERIA;
 464
 465         /* Test search criteria */
 466         if( ldapServer->searchCriteria == NULL ) {
 467                 return FALSE;
 468         }
 469         if( strlen( ldapServer->searchCriteria ) < 1 ) {
 470                 return FALSE;
 471         }
 472
 473         if( ldapServer->searchValue == NULL ) {
 474                 return FALSE;
 475         }
 476         if( strlen( ldapServer->searchValue ) < 1 ) {
 477                 return FALSE;
 478         }
 479
 480         ldapServer->retVal = MGU_SUCCESS;
 481         return TRUE;
 482 }
 483
 484 /*
 485 * Perform the LDAP search, reading LDAP entries into cache.
 486 * Note that one LDAP entry can have multiple values for many of its
 487 * attributes. If these attributes are E-Mail addresses; these are
 488 * broken out into separate address items. For any other attribute,
 489 * only the first occurrence is read.
 490 */
 491 gint syldap_search( SyldapServer *ldapServer ) {
 492         LDAP *ld;
 493         LDAPMessage *result, *e;
 494         char *attribs[10];
 495         char *attribute;
 496         gchar *criteria;
 497         BerElement *ber;
 498         gint rc;
 499         GSList *listName = NULL, *listAddress = NULL, *listID = NULL;
 500         GSList *listFirst = NULL, *listLast = NULL, *listDN = NULL;
 501         struct timeval timeout;
 502         gboolean entriesFound = FALSE;
 503
 504         g_return_val_if_fail( ldapServer != NULL, -1 );
 505
 506         ldapServer->retVal = MGU_SUCCESS;
 507         if( ! syldap_check_search( ldapServer ) ) {
 508                 return ldapServer->retVal;
 509         }
 510
 511         /* Set timeout */
 512         timeout.tv_sec = ldapServer->timeOut;
 513         timeout.tv_usec = 0L;
 514
 515         ldapServer->entriesRead = 0;
 516         if( ( ld = ldap_init( ldapServer->hostName, ldapServer->port ) ) == NULL ) {
 517                 ldapServer->retVal = MGU_LDAP_INIT;
 518                 return ldapServer->retVal;
 519         }
 520
 521         /* printf( "connected to LDAP host %s on port %d\n", ldapServer->hostName, ldapServer->port ); */
 522
 523         /* Bind to the server, if required */
 524         if( ldapServer->bindDN ) {
 525                 if( * ldapServer->bindDN != '\0' ) {
 526                         /* printf( "binding...\n" ); */
 527                         rc = ldap_simple_bind_s( ld, ldapServer->bindDN, ldapServer->bindPass );
 528                         /* printf( "rc=%d\n", rc ); */
 529                         if( rc != LDAP_SUCCESS ) {
 530                                 /* printf( "LDAP Error: ldap_simple_bind_s: %s\n", ldap_err2string( rc ) ); */
 531                                 ldap_unbind( ld );
 532                                 ldapServer->retVal = MGU_LDAP_BIND;
 533                                 return ldapServer->retVal;
 534                         }
 535                 }
 536         }
 537
 538         /* Define all attributes we are interested in. */
 539         attribs[0] = SYLDAP_ATTR_DN;
 540         attribs[1] = SYLDAP_ATTR_COMMONNAME;
 541         attribs[2] = SYLDAP_ATTR_GIVENNAME;
 542         attribs[3] = SYLDAP_ATTR_SURNAME;
 543         attribs[4] = SYLDAP_ATTR_EMAIL;
 544         attribs[5] = SYLDAP_ATTR_UID;
 545         attribs[6] = NULL;
 546
 547         /* Create LDAP search string and apply search criteria */
 548         criteria = g_strdup_printf( ldapServer->searchCriteria, ldapServer->searchValue );
 549         rc = ldap_search_ext_s( ld, ldapServer->baseDN, LDAP_SCOPE_SUBTREE, criteria, attribs, 0, NULL, NULL,
 550                        &timeout, 0, &result );
 551         g_free( criteria );
 552         criteria = NULL;
 553         if( rc == LDAP_TIMEOUT ) {
 554                 ldap_unbind( ld );
 555                 ldapServer->retVal = MGU_LDAP_TIMEOUT;
 556                 return ldapServer->retVal;
 557         }
 558         if( rc != LDAP_SUCCESS ) {
 559                 /* printf( "LDAP Error: ldap_search_st: %s\n", ldap_err2string( rc ) ); */
 560                 ldap_unbind( ld );
 561                 ldapServer->retVal = MGU_LDAP_SEARCH;
 562                 return ldapServer->retVal;
 563         }
 564
 565         /* printf( "Total results are: %d\n", ldap_count_entries( ld, result ) ); */
 566
 567         /* Clear the cache if we have new entries, otherwise leave untouched. */
 568         if( ldap_count_entries( ld, result ) > 0 ) {
 569                 addrcache_clear( ldapServer->addressCache );
 570         }
 571
 572         /* Process results */
 573         ldapServer->entriesRead = 0;
 574         for( e = ldap_first_entry( ld, result ); e != NULL; e = ldap_next_entry( ld, e ) ) {
 575                 entriesFound = TRUE;
 576                 if( ldapServer->entriesRead >= ldapServer->maxEntries ) break;
 577                 /* printf( "DN: %s\n", ldap_get_dn( ld, e ) ); */
 578
 579                 /* Process all attributes */
 580                 for( attribute = ldap_first_attribute( ld, e, &ber ); attribute != NULL;
 581                                attribute = ldap_next_attribute( ld, e, ber ) ) {
 582                         if( strcasecmp( attribute, SYLDAP_ATTR_COMMONNAME ) == 0 ) {
 583                                 listName = syldap_add_list_values( ld, e, attribute );
 584                         }
 585                         if( strcasecmp( attribute, SYLDAP_ATTR_EMAIL ) == 0 ) {
 586                                 listAddress = syldap_add_list_values( ld, e, attribute );
 587                         }
 588                         if( strcasecmp( attribute, SYLDAP_ATTR_UID ) == 0 ) {
 589                                 listID = syldap_add_single_value( ld, e, attribute );
 590                         }
 591                         if( strcasecmp( attribute, SYLDAP_ATTR_GIVENNAME ) == 0 ) {
 592                                 listFirst = syldap_add_list_values( ld, e, attribute );
 593                         }
 594                         if( strcasecmp( attribute, SYLDAP_ATTR_SURNAME ) == 0 ) {
 595                                 listLast = syldap_add_single_value( ld, e, attribute );
 596                         }
 597                         if( strcasecmp( attribute, SYLDAP_ATTR_DN ) == 0 ) {
 598                                 listDN = syldap_add_single_value( ld, e, attribute );
 599                         }
 600                 }
 601
 602                 /* Free memory used to store attribute */
 603                 ldap_memfree( attribute );
 604
 605                 /* Format and add items to cache */
 606                 syldap_build_items_fl( ldapServer, listAddress, listFirst, listLast );
 607
 608                 /* Free up */
 609                 syldap_free_lists( listName, listAddress, listID, listDN, listFirst, listLast );
 610                 listName = listAddress = listID = listFirst = listLast = listDN = NULL;
 611
 612                 if( ber != NULL ) {
 613                         ber_free( ber, 0 );
 614                 }
 615         }
 616
 617         syldap_free_lists( listName, listAddress, listID, listDN, listFirst, listLast );
 618         listName = listAddress = listID = listFirst = listLast = listDN = NULL;
 619
 620         /* Free up and disconnect */
 621         ldap_msgfree( result );
 622         ldap_unbind( ld );
 623         ldapServer->newSearch = FALSE;
 624         if( entriesFound ) {
 625                 ldapServer->retVal = MGU_SUCCESS;
 626         }
 627         else {
 628                 ldapServer->retVal = MGU_LDAP_NOENTRIES;
 629         }
 630         return ldapServer->retVal;
 631 }
 632
 633 /* ============================================================================================ */
 634 /*
 635 * Read data into list. Main entry point
 636 * Return: TRUE if file read successfully.
 637 */
 638 /* ============================================================================================ */
 639 gint syldap_read_data( SyldapServer *ldapServer ) {
 640         g_return_val_if_fail( ldapServer != NULL, -1 );
 641
 642         ldapServer->accessFlag = FALSE;
 643         pthread_detach( pthread_self() );
 644         if( ldapServer->newSearch ) {
 645                 /* Read data into the list */
 646                 syldap_search( ldapServer );
 647
 648                 /* Mark cache */
 649                 ldapServer->addressCache->modified = FALSE;
 650                 ldapServer->addressCache->dataRead = TRUE;
 651                 ldapServer->accessFlag = FALSE;
 652         }
 653
 654         /* Callback */
 655         ldapServer->busyFlag = FALSE;
 656         if( ldapServer->callBack ) {
 657                 ( ldapServer->callBack )( ldapServer );
 658         }
 659         /* The thread struct should not be freed inside the thread
 660         g_free(ldapServer->thread);
 661         ldapServer->thread = NULL;
 662         pthread_exit( NULL );
 663         */
 664         return ldapServer->retVal;
 665 }
 666
 667 /* ============================================================================================ */
 668 /*
 669 * Cancel read with thread.
 670 */
 671 /* ============================================================================================ */
 672 void syldap_cancel_read( SyldapServer *ldapServer ) {
 673         g_return_if_fail( ldapServer != NULL );
 674
 675         if( ldapServer->thread ) {
 676                 /* printf( "thread cancelled\n" ); */
 677                 /* The thread is cancleing itself, ok?
 678                 pthread_cancel( *ldapServer->thread );
 679                 */
 680         }
 681         /* The thread struct should not be freed inside the thread
 682         g_free(ldapServer->thread);
 683         ldapServer->thread = NULL;
 684         */
 685         ldapServer->busyFlag = FALSE;
 686 }
 687
 688 /* ============================================================================================ */
 689 /*
 690 * Read data into list using a background thread.
 691 * Return: TRUE if file read successfully. Callback function will be
 692 * notified when search is complete.
 693 */
 694 /* ============================================================================================ */
 695 gint syldap_read_data_th( SyldapServer *ldapServer ) {
 696         g_return_val_if_fail( ldapServer != NULL, -1 );
 697
 698         ldapServer->busyFlag = FALSE;
 699         syldap_check_search( ldapServer );
 700         if( ldapServer->retVal == MGU_SUCCESS ) {
 701                 debug_print("Staring LDAP read thread\n");
 702
 703                 ldapServer->busyFlag = TRUE;
 704                 ldapServer->thread = g_new0(pthread_t, 1);
 705                 pthread_create( ldapServer->thread, NULL, (void *) &syldap_read_data, (void *) ldapServer );
 706         }
 707         return ldapServer->retVal;
 708 }
 709
 710 /*
 711 * Return link list of persons.
 712 */
 713 GList *syldap_get_list_person( SyldapServer *ldapServer ) {
 714         g_return_val_if_fail( ldapServer != NULL, NULL );
 715         return addrcache_get_list_person( ldapServer->addressCache );
 716 }
 717
 718 /*
 719 * Return link list of folders. This is always NULL since there are
 720 * no folders in GnomeCard.
 721 * Return: NULL.
 722 */
 723 GList *syldap_get_list_folder( SyldapServer *ldapServer ) {
 724         g_return_val_if_fail( ldapServer != NULL, NULL );
 725         return NULL;
 726 }
 727
 728 #define SYLDAP_TEST_FILTER   "(objectclass=*)"
 729 #define SYLDAP_SEARCHBASE_V2 "cn=config"
 730 #define SYLDAP_SEARCHBASE_V3 ""
 731 #define SYLDAP_V2_TEST_ATTR  "database"
 732 #define SYLDAP_V3_TEST_ATTR  "namingcontexts"
 733
 734 /*
 735 * Attempt to discover the base DN for the server.
 736 * Enter:
 737 *       host    Host name
 738 *       port    Port number
 739 *       bindDN  Bind DN (optional).
 740 *       bindPW  Bind PW (optional).
 741 *       tov     Timeout value (seconds), or 0 for none, default 30 secs.
 742 * Return: List of Base DN's, or NULL if could not read. Base DN should
 743 * be g_free() when done.
 744 */
 745 GList *syldap_read_basedn_s( const gchar *host, const gint port, const gchar *bindDN, const gchar *bindPW, const gint tov ) {
 746         GList *baseDN = NULL;
 747         LDAP *ld;
 748         gint rc, i;
 749         LDAPMessage *result, *e;
 750         gchar *attribs[10];
 751         BerElement *ber;
 752         gchar *attribute;
 753         gchar **vals;
 754         struct timeval timeout;
 755
 756         if( host == NULL ) return baseDN;
 757         if( port < 1 ) return baseDN;
 758
 759         /* Set timeout */
 760         timeout.tv_usec = 0L;
 761         if( tov > 0 ) {
 762                 timeout.tv_sec = tov;
 763         }
 764         else {
 765                 timeout.tv_sec = 30L;
 766         }
 767
 768         /* Connect to server. */
 769         if( ( ld = ldap_init( host, port ) ) == NULL ) {
 770                 return baseDN;
 771         }
 772
 773         /* Bind to the server, if required */
 774         if( bindDN ) {
 775                 if( *bindDN != '\0' ) {
 776                         rc = ldap_simple_bind_s( ld, bindDN, bindPW );
 777                         if( rc != LDAP_SUCCESS ) {
 778                                 /* printf( "LDAP Error: ldap_simple_bind_s: %s\n", ldap_err2string( rc ) ); */
 779                                 ldap_unbind( ld );
 780                                 return baseDN;
 781                         }
 782                 }
 783         }
 784
 785         /* Test for LDAP version 3 */
 786         attribs[0] = SYLDAP_V3_TEST_ATTR;
 787         attribs[1] = NULL;
 788         rc = ldap_search_ext_s( ld, SYLDAP_SEARCHBASE_V3, LDAP_SCOPE_BASE, SYLDAP_TEST_FILTER, attribs,
 789                        0, NULL, NULL, &timeout, 0, &result );
 790         if( rc == LDAP_SUCCESS ) {
 791                 /* Process entries */
 792                 for( e = ldap_first_entry( ld, result ); e != NULL; e = ldap_next_entry( ld, e ) ) {
 793                         /* printf( "DN: %s\n", ldap_get_dn( ld, e ) ); */
 794
 795                         /* Process attributes */
 796                         for( attribute = ldap_first_attribute( ld, e, &ber ); attribute != NULL;
 797                                         attribute = ldap_next_attribute( ld, e, ber ) ) {
 798                                 if( strcasecmp( attribute, SYLDAP_V3_TEST_ATTR ) == 0 ) {
 799                                         if( ( vals = ldap_get_values( ld, e, attribute ) ) != NULL ) {
 800                                                 for( i = 0; vals[i] != NULL; i++ ) {
 801                                                         /* printf( "\t%s: %s\n", attribute, vals[i] ); */
 802                                                         baseDN = g_list_append( baseDN, g_strdup( vals[i] ) );
 803                                                 }
 804                                         }
 805                                         ldap_value_free( vals );
 806                                 }
 807                         }
 808                         ldap_memfree( attribute );
 809                         if( ber != NULL ) {
 810                                 ber_free( ber, 0 );
 811                         }
 812                 }
 813                 ldap_msgfree( result );
 814         }
 815         else {
 816         }
 817
 818         if( baseDN == NULL ) {
 819                 /* Test for LDAP version 2 */
 820                 attribs[0] = NULL;
 821                 rc = ldap_search_ext_s( ld, SYLDAP_SEARCHBASE_V2, LDAP_SCOPE_BASE, SYLDAP_TEST_FILTER, attribs,
 822                                0, NULL, NULL, &timeout, 0, &result );
 823                 if( rc == LDAP_SUCCESS ) {
 824                         /* Process entries */
 825                         for( e = ldap_first_entry( ld, result ); e != NULL; e = ldap_next_entry( ld, e ) ) {
 826                                 /* if( baseDN ) break;                   */
 827                                 /* printf( "DN: %s\n", ldap_get_dn( ld, e ) ); */
 828
 829                                 /* Process attributes */
 830                                 for( attribute = ldap_first_attribute( ld, e, &ber ); attribute != NULL;
 831                                                attribute = ldap_next_attribute( ld, e, ber ) ) {
 832                                         /* if( baseDN ) break;                   */
 833                                         if( strcasecmp( attribute, SYLDAP_V2_TEST_ATTR ) == 0 ) {
 834                                                 if( ( vals = ldap_get_values( ld, e, attribute ) ) != NULL ) {
 835                                                         for( i = 0; vals[i] != NULL; i++ ) {
 836                                                                 char *ch;
 837                                                                 /* Strip the 'ldb:' from the front of the value */
 838                                                                 ch = ( char * ) strchr( vals[i], ':' );
 839                                                                 if( ch ) {
 840                                                                         gchar *bn = g_strdup( ++ch );
 841                                                                         g_strchomp( bn );
 842                                                                         g_strchug( bn );
 843                                                                         baseDN = g_list_append( baseDN, g_strdup( bn ) );
 844                                                                 }
 845                                                         }
 846                                                 }
 847                                                 ldap_value_free( vals );
 848                                         }
 849                                 }
 850                                 ldap_memfree( attribute );
 851                                 if( ber != NULL ) {
 852                                         ber_free( ber, 0 );
 853                                 }
 854                         }
 855                         ldap_msgfree( result );
 856                 }
 857         }
 858         ldap_unbind( ld );
 859         return baseDN;
 860 }
 861
 862 /*
 863 * Attempt to discover the base DN for the server.
 864 * Enter:  ldapServer Server to test.
 865 * Return: List of Base DN's, or NULL if could not read. Base DN should
 866 * be g_free() when done. Return code set in ldapServer.
 867 */
 868 GList *syldap_read_basedn( SyldapServer *ldapServer ) {
 869         GList *baseDN = NULL;
 870         LDAP *ld;
 871         gint rc, i;
 872         LDAPMessage *result, *e;
 873         gchar *attribs[10];
 874         BerElement *ber;
 875         gchar *attribute;
 876         gchar **vals;
 877         struct timeval timeout;
 878
 879         ldapServer->retVal = MGU_BAD_ARGS;
 880         if( ldapServer == NULL ) return baseDN;
 881         if( ldapServer->hostName == NULL ) return baseDN;
 882         if( ldapServer->port < 1 ) return baseDN;
 883
 884         /* Set timeout */
 885         timeout.tv_usec = 0L;
 886         if( ldapServer->timeOut > 0 ) {
 887                 timeout.tv_sec = ldapServer->timeOut;
 888         }
 889         else {
 890                 timeout.tv_sec = 30L;
 891         }
 892
 893         /* Connect to server. */
 894         if( ( ld = ldap_init( ldapServer->hostName, ldapServer->port ) ) == NULL ) {
 895                 ldapServer->retVal = MGU_LDAP_INIT;
 896                 return baseDN;
 897         }
 898
 899         /* Bind to the server, if required */
 900         if( ldapServer->bindDN ) {
 901                 if( *ldapServer->bindDN != '\0' ) {
 902                         rc = ldap_simple_bind_s( ld, ldapServer->bindDN, ldapServer->bindPass );
 903                         if( rc != LDAP_SUCCESS ) {
 904                                 /* printf( "LDAP Error: ldap_simple_bind_s: %s\n", ldap_err2string( rc ) ); */
 905                                 ldap_unbind( ld );
 906                                 ldapServer->retVal = MGU_LDAP_BIND;
 907                                 return baseDN;
 908                         }
 909                 }
 910         }
 911
 912         ldapServer->retVal = MGU_LDAP_SEARCH;
 913
 914         /* Test for LDAP version 3 */
 915         attribs[0] = SYLDAP_V3_TEST_ATTR;
 916         attribs[1] = NULL;
 917         rc = ldap_search_ext_s( ld, SYLDAP_SEARCHBASE_V3, LDAP_SCOPE_BASE, SYLDAP_TEST_FILTER, attribs,
 918                        0, NULL, NULL, &timeout, 0, &result );
 919         if( rc == LDAP_SUCCESS ) {
 920                 /* Process entries */
 921                 for( e = ldap_first_entry( ld, result ); e != NULL; e = ldap_next_entry( ld, e ) ) {
 922                         /* printf( "DN: %s\n", ldap_get_dn( ld, e ) ); */
 923
 924                         /* Process attributes */
 925                         for( attribute = ldap_first_attribute( ld, e, &ber ); attribute != NULL;
 926                                         attribute = ldap_next_attribute( ld, e, ber ) ) {
 927                                 if( strcasecmp( attribute, SYLDAP_V3_TEST_ATTR ) == 0 ) {
 928                                         if( ( vals = ldap_get_values( ld, e, attribute ) ) != NULL ) {
 929                                                 for( i = 0; vals[i] != NULL; i++ ) {
 930                                                         /* printf( "\t%s: %s\n", attribute, vals[i] ); */
 931                                                         baseDN = g_list_append( baseDN, g_strdup( vals[i] ) );
 932                                                 }
 933                                         }
 934                                         ldap_value_free( vals );
 935                                 }
 936                         }
 937                         ldap_memfree( attribute );
 938                         if( ber != NULL ) {
 939                                 ber_free( ber, 0 );
 940                         }
 941                 }
 942                 ldap_msgfree( result );
 943                 ldapServer->retVal = MGU_SUCCESS;
 944         }
 945         else if( rc == LDAP_TIMEOUT ) {
 946                 ldapServer->retVal = MGU_LDAP_TIMEOUT;
 947         }
 948
 949         if( baseDN == NULL ) {
 950                 /* Test for LDAP version 2 */
 951                 attribs[0] = NULL;
 952                 rc = ldap_search_ext_s( ld, SYLDAP_SEARCHBASE_V2, LDAP_SCOPE_BASE, SYLDAP_TEST_FILTER, attribs,
 953                                0, NULL, NULL, &timeout, 0, &result );
 954                 if( rc == LDAP_SUCCESS ) {
 955                         /* Process entries */
 956                         for( e = ldap_first_entry( ld, result ); e != NULL; e = ldap_next_entry( ld, e ) ) {
 957                                 /* if( baseDN ) break;                   */
 958                                 /* printf( "DN: %s\n", ldap_get_dn( ld, e ) ); */
 959
 960                                 /* Process attributes */
 961                                 for( attribute = ldap_first_attribute( ld, e, &ber ); attribute != NULL;
 962                                                attribute = ldap_next_attribute( ld, e, ber ) ) {
 963                                         /* if( baseDN ) break;                   */
 964                                         if( strcasecmp( attribute, SYLDAP_V2_TEST_ATTR ) == 0 ) {
 965                                                 if( ( vals = ldap_get_values( ld, e, attribute ) ) != NULL ) {
 966                                                         for( i = 0; vals[i] != NULL; i++ ) {
 967                                                                 char *ch;
 968                                                                 /* Strip the 'ldb:' from the front of the value */
 969                                                                 ch = ( char * ) strchr( vals[i], ':' );
 970                                                                 if( ch ) {
 971                                                                         gchar *bn = g_strdup( ++ch );
 972                                                                         g_strchomp( bn );
 973                                                                         g_strchug( bn );
 974                                                                         baseDN = g_list_append( baseDN, g_strdup( bn ) );
 975                                                                 }
 976                                                         }
 977                                                 }
 978                                                 ldap_value_free( vals );
 979                                         }
 980                                 }
 981                                 ldap_memfree( attribute );
 982                                 if( ber != NULL ) {
 983                                         ber_free( ber, 0 );
 984                                 }
 985                         }
 986                         ldap_msgfree( result );
 987                         ldapServer->retVal = MGU_SUCCESS;
 988                 }
 989                 else if( rc == LDAP_TIMEOUT ) {
 990                         ldapServer->retVal = MGU_LDAP_TIMEOUT;
 991                 }
 992         }
 993         ldap_unbind( ld );
 994
 995         return baseDN;
 996 }
 997
 998 /*
 999 * Attempt to connect to the server.
1000 * Enter:
1001 *       host    Host name
1002 *       port    Port number
1003 * Return: TRUE if connected successfully.
1004 */
1005 gboolean syldap_test_connect_s( const gchar *host, const gint port ) {
1006         gboolean retVal = FALSE;
1007         LDAP *ld;
1008
1009         if( host == NULL ) return retVal;
1010         if( port < 1 ) return retVal;
1011         if( ( ld = ldap_open( host, port ) ) != NULL ) {
1012                 retVal = TRUE;
1013         }
1014         if( ld != NULL ) {
1015                 ldap_unbind( ld );
1016         }
1017         return retVal;
1018 }
1019
1020 /*
1021 * Attempt to connect to the server.
1022 * Enter:  ldapServer Server to test.
1023 * Return: TRUE if connected successfully. Return code set in ldapServer.
1024 */
1025 gboolean syldap_test_connect( SyldapServer *ldapServer ) {
1026         gboolean retVal = FALSE;
1027         LDAP *ld;
1028
1029         ldapServer->retVal = MGU_BAD_ARGS;
1030         if( ldapServer == NULL ) return retVal;
1031         if( ldapServer->hostName == NULL ) return retVal;
1032         if( ldapServer->port < 1 ) return retVal;
1033         ldapServer->retVal = MGU_LDAP_INIT;
1034         if( ( ld = ldap_open( ldapServer->hostName, ldapServer->port ) ) != NULL ) {
1035                 ldapServer->retVal = MGU_SUCCESS;
1036                 retVal = TRUE;
1037         }
1038         if( ld != NULL ) {
1039                 ldap_unbind( ld );
1040         }
1041         return retVal;
1042 }
1043
1044 #define LDAP_LINK_LIB_NAME_1 "libldap.so"
1045 #define LDAP_LINK_LIB_NAME_2 "liblber.so"
1046 #define LDAP_LINK_LIB_NAME_3 "libresolv.so"
1047 #define LDAP_LINK_LIB_NAME_4 "libpthread.so"
1048
1049 /*
1050 * Test whether LDAP libraries installed.
1051 * Return: TRUE if library available.
1052 */
1053 gboolean syldap_test_ldap_lib() {
1054         void *handle, *fun;
1055
1056         /* Get library */
1057         handle = dlopen( LDAP_LINK_LIB_NAME_1, RTLD_LAZY );
1058         if( ! handle ) {
1059                 return FALSE;
1060         }
1061
1062         /* Test for symbols we need */
1063         fun = dlsym( handle, "ldap_init" );
1064         if( ! fun ) {
1065                 dlclose( handle );
1066                 return FALSE;
1067         }
1068         dlclose( handle ); handle = NULL; fun = NULL;
1069
1070         handle = dlopen( LDAP_LINK_LIB_NAME_2, RTLD_LAZY );
1071         if( ! handle ) {
1072                 return FALSE;
1073         }
1074         fun = dlsym( handle, "ber_init" );
1075         if( ! fun ) {
1076                 dlclose( handle );
1077                 return FALSE;
1078         }
1079         dlclose( handle ); handle = NULL; fun = NULL;
1080
1081         handle = dlopen( LDAP_LINK_LIB_NAME_3, RTLD_LAZY );
1082         if( ! handle ) {
1083                 return FALSE;
1084         }
1085         fun = dlsym( handle, "res_query" );
1086         if( ! fun ) {
1087                 dlclose( handle );
1088                 return FALSE;
1089         }
1090         dlclose( handle ); handle = NULL; fun = NULL;
1091
1092         handle = dlopen( LDAP_LINK_LIB_NAME_4, RTLD_LAZY );
1093         if( ! handle ) {
1094                 return FALSE;
1095         }
1096         fun = dlsym( handle, "pthread_create" );
1097         if( ! fun ) {
1098                 dlclose( handle );
1099                 return FALSE;
1100         }
1101         dlclose( handle ); handle = NULL; fun = NULL;
1102
1103         return TRUE;
1104 }
1105
1106 #endif  /* USE_LDAP */
1107
1108 /*
1109 * End of Source.
1110 */