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