2006-12-13 [colin] 2.6.1cvs30
[claws.git] / src / ldaputil.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2003-2006 Match Grun and the Claws Mail team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  */
19
20 /*
21  * Some utility functions 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 <string.h>
32 #include <sys/time.h>
33 #include <ldap.h>
34 #include <lber.h>
35 #include <errno.h>
36
37 #define SYLDAP_TEST_FILTER   "(objectclass=*)"
38 #define SYLDAP_SEARCHBASE_V2 "cn=config"
39 #define SYLDAP_SEARCHBASE_V3 ""
40 #define SYLDAP_V2_TEST_ATTR  "database"
41 #define SYLDAP_V3_TEST_ATTR  "namingcontexts"
42
43 /**
44  * Attempt to discover the base DN for a server using LDAP version 3.
45  * \param  ld  LDAP handle for a connected server.
46  * \param  tov Timeout value (seconds), or 0 for none, default 30 secs.
47  * \return List of Base DN's, or NULL if could not read. List should be
48  *         g_free() when done.
49  */
50 static GList *ldaputil_test_v3( LDAP *ld, gint tov, gint *errcode ) {
51         GList *baseDN = NULL;
52         gint rc, i;
53         LDAPMessage *result = NULL, *e;
54         gchar *attribs[2];
55         BerElement *ber;
56         gchar *attribute;
57         struct berval **vals;
58         struct timeval timeout;
59
60         /* Set timeout */
61         timeout.tv_usec = 0L;
62         if( tov > 0 ) {
63                 timeout.tv_sec = tov;
64         }
65         else {
66                 timeout.tv_sec = 30L;
67         }
68
69         /* Test for LDAP version 3 */
70         attribs[0] = SYLDAP_V3_TEST_ATTR;
71         attribs[1] = NULL;
72         rc = ldap_search_ext_s(
73                 ld, SYLDAP_SEARCHBASE_V3, LDAP_SCOPE_BASE, SYLDAP_TEST_FILTER,
74                 attribs, 0, NULL, NULL, &timeout, 0, &result );
75
76         if( rc == LDAP_SUCCESS ) {
77                 /* Process entries */
78                 for( e = ldap_first_entry( ld, result );
79                      e != NULL;
80                      e = ldap_next_entry( ld, e ) ) 
81                 {
82                         /* Process attributes */
83                         for( attribute = ldap_first_attribute( ld, e, &ber );
84                              attribute != NULL;
85                              attribute = ldap_next_attribute( ld, e, ber ) )
86                         {
87                                 if( strcasecmp(
88                                         attribute, SYLDAP_V3_TEST_ATTR ) == 0 )
89                                 {
90                                         vals = ldap_get_values_len( ld, e, attribute );
91                                         if( vals != NULL ) {
92                                                 for( i = 0; vals[i] != NULL; i++ ) {
93                                                         baseDN = g_list_append(
94                                                                 baseDN, g_strndup( vals[i]->bv_val, vals[i]->bv_len ) );
95                                                 }
96                                         }
97                                         ldap_value_free_len( vals );
98                                 }
99                                 ldap_memfree( attribute );
100                         }
101                         if( ber != NULL ) {
102                                 ber_free( ber, 0 );
103                         }
104                         ber = NULL;
105                 }
106         } 
107         if (errcode)
108                 *errcode = rc;
109         if (result)
110                 ldap_msgfree( result );
111         return baseDN;
112 }
113
114 /**
115  * Attempt to discover the base DN for a server using LDAP version 2.
116  * \param  ld  LDAP handle for a connected server.
117  * \param  tov Timeout value (seconds), or 0 for none, default 30 secs.
118  * \return List of Base DN's, or NULL if could not read. List should be
119  *         g_free() when done.
120  */
121 static GList *ldaputil_test_v2( LDAP *ld, gint tov ) {
122         GList *baseDN = NULL;
123         gint rc, i;
124         LDAPMessage *result = NULL, *e;
125         gchar *attribs[1];
126         BerElement *ber;
127         gchar *attribute;
128         struct berval **vals;
129         struct timeval timeout;
130
131         /* Set timeout */
132         timeout.tv_usec = 0L;
133         if( tov > 0 ) {
134                 timeout.tv_sec = tov;
135         }
136         else {
137                 timeout.tv_sec = 30L;
138         }
139
140         attribs[0] = NULL;
141         rc = ldap_search_ext_s(
142                 ld, SYLDAP_SEARCHBASE_V2, LDAP_SCOPE_BASE, SYLDAP_TEST_FILTER,
143                 attribs, 0, NULL, NULL, &timeout, 0, &result );
144
145         if( rc == LDAP_SUCCESS ) {
146                 /* Process entries */
147                 for( e = ldap_first_entry( ld, result );
148                      e != NULL;
149                      e = ldap_next_entry( ld, e ) )
150                 {
151                         /* Process attributes */
152                         for( attribute = ldap_first_attribute( ld, e, &ber );
153                              attribute != NULL;
154                              attribute = ldap_next_attribute( ld, e, ber ) )
155                         {
156                                 if( strcasecmp(
157                                         attribute,
158                                         SYLDAP_V2_TEST_ATTR ) == 0 ) {
159                                         vals = ldap_get_values_len( ld, e, attribute );
160                                         if( vals != NULL ) {
161                                                 for( i = 0; vals[i] != NULL; i++ ) {
162                                                         char *ch, *tmp;
163                                                         /*
164                                                          * Strip the 'ldb:' from the
165                                                          * front of the value.
166                                                          */
167                                                         tmp = g_strndup( vals[i]->bv_val, vals[i]->bv_len);
168                                                         ch = ( char * ) strchr( tmp, ':' );
169                                                         if( ch ) {
170                                                                 gchar *bn = g_strdup( ++ch );
171                                                                 g_strchomp( bn );
172                                                                 g_strchug( bn );
173                                                                 baseDN = g_list_append(
174                                                                         baseDN, g_strdup( bn ) );
175                                                                 g_free( bn );
176                                                         }
177                                                         g_free(tmp);
178                                                 }
179                                         }
180                                         ldap_value_free_len( vals );
181                                 }
182                                 ldap_memfree( attribute );
183                         }
184                         if( ber != NULL ) {
185                                 ber_free( ber, 0 );
186                         }
187                         ber = NULL;
188                 }
189         }
190         if (result)
191                 ldap_msgfree( result );
192         return baseDN;
193 }
194
195 /**
196  * Attempt to discover the base DN for the server.
197  * \param  host   Host name.
198  * \param  port   Port number.
199  * \param  bindDN Bind DN (optional).
200  * \param  bindPW Bind PW (optional).
201  * \param  tov    Timeout value (seconds), or 0 for none, default 30 secs.
202  * \return List of Base DN's, or NULL if could not read. This list should be
203  *         g_free() when done.
204  */
205 GList *ldaputil_read_basedn(
206                 const gchar *host, const gint port, const gchar *bindDN,
207                 const gchar *bindPW, const gint tov, int ssl, int tls )
208 {
209         GList *baseDN = NULL;
210         LDAP *ld = NULL;
211         gint rc;
212 #ifdef USE_LDAP_TLS
213         gint version;
214 #endif
215
216         if( host == NULL ) return baseDN;
217         if( port < 1 ) return baseDN;
218
219         /* Connect to server. */
220
221         if (!ssl) {
222                 ld = ldap_init( host, port );
223         } else {
224                 gchar *uri = g_strdup_printf("ldaps://%s:%d",
225                                 host, port);
226                 rc = ldap_initialize(&ld, uri);
227                 g_free(uri);
228         }
229         if( ld == NULL ) {
230                 return baseDN;
231         }
232 #ifdef USE_LDAP_TLS
233         if( tls && !ssl ) {
234                 /* Handle TLS */
235                 version = LDAP_VERSION3;
236                 rc = ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION, &version );
237                 if( rc != LDAP_OPT_SUCCESS ) {
238                         ldap_unbind( ld );
239                         return baseDN;
240                 }
241                 rc = ldap_start_tls_s( ld, NULL, NULL );
242                 if (rc != 0) {
243                         ldap_unbind( ld );
244                         return baseDN;
245                 }
246         }
247 #endif
248
249         /* Bind to the server, if required */
250         if( bindDN ) {
251                 if( *bindDN != '\0' ) {
252                         rc = ldap_simple_bind_s( ld, bindDN, bindPW );
253                         if( rc != LDAP_SUCCESS ) {
254                                 ldap_unbind( ld );
255                                 return baseDN;
256                         }
257                 }
258         }
259
260         /* Test for LDAP version 3 */
261         baseDN = ldaputil_test_v3( ld, tov, &rc );
262
263         if( baseDN == NULL && !LDAP_API_ERROR(rc) ) {
264                 baseDN = ldaputil_test_v2( ld, tov );
265         }
266         if (ld && !LDAP_API_ERROR(rc))
267                 ldap_unbind( ld );
268         
269         return baseDN;
270 }
271
272 /**
273  * Attempt to connect to the server.
274  * Enter:
275  * \param  host Host name.
276  * \param  port Port number.
277  * \return <i>TRUE</i> if connected successfully.
278  */
279 gboolean ldaputil_test_connect( const gchar *host, const gint port, int ssl, int tls ) {
280         gboolean retVal = FALSE;
281         LDAP *ld;
282 #ifdef USE_LDAP_TLS
283         gint rc;
284         gint version;
285 #endif
286         if( host == NULL ) return retVal;
287         if( port < 1 ) return retVal;
288         if (!ssl) {
289                 ld = ldap_open( host, port );
290         } else {
291                 gchar *uri = g_strdup_printf("ldaps://%s:%d",
292                                 host, port);
293                 ldap_initialize(&ld, uri);
294                 g_free(uri);
295         }
296         if (ld == NULL)
297                 return FALSE;
298
299 #ifdef USE_LDAP_TLS
300         if (ssl) {
301                 GList *dummy = ldaputil_test_v3( ld, 10, &rc );
302                 if (dummy)
303                         g_list_free(dummy);
304                 if (LDAP_API_ERROR(rc))
305                         return FALSE;
306         }
307
308         if( tls && !ssl ) {
309                 /* Handle TLS */
310                 version = LDAP_VERSION3;
311                 rc = ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION, &version );
312                 if( rc != LDAP_OPT_SUCCESS ) {
313                         ldap_unbind( ld );
314                         return FALSE;
315                 }
316
317                 rc = ldap_start_tls_s( ld, NULL, NULL );
318                 if (rc != 0) {
319                         ldap_unbind( ld );
320                         return FALSE;
321                 }
322         }
323 #endif
324         if( ld != NULL ) {
325                 ldap_unbind( ld );
326                 retVal = TRUE;
327         }
328         return retVal;
329 }
330
331 /**
332  * Test whether LDAP libraries installed.
333  * Return: TRUE if library available.
334  */
335 gboolean ldaputil_test_ldap_lib( void ) {
336         return TRUE;
337 }
338
339 #endif  /* USE_LDAP */
340
341 /*
342  * End of Source.
343 */