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