2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 2003-2004 Match Grun
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.
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.
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.
21 * Functions necessary to access LDAP servers.
38 #include "addrcache.h"
40 #include "ldapquery.h"
41 #include "ldapserver.h"
43 #include "adbookbase.h"
46 * Create new LDAP server interface object with no control object.
47 * \return Initialized LDAP server object.
49 LdapServer *ldapsvr_create_noctl( void ) {
52 server = g_new0( LdapServer, 1 );
53 server->type = ADBOOKTYPE_LDAP;
54 server->addressCache = addrcache_create();
55 server->retVal = MGU_SUCCESS;
56 server->control = NULL;
57 server->listQuery = NULL;
58 server->searchFlag = FALSE;
63 * Create new LDAP server interface object.
64 * \return Initialized LDAP server object.
66 LdapServer *ldapsvr_create( void ) {
69 server = ldapsvr_create_noctl();
70 server->control = ldapctl_create();
75 * Return name of server.
76 * \param server Server object.
77 * \return Name for server.
79 gchar *ldapsvr_get_name( LdapServer *server ) {
80 g_return_val_if_fail( server != NULL, NULL );
81 return addrcache_get_name( server->addressCache );
85 * Specify name to be used.
86 * \param server Server object.
87 * \param value Name for server.
89 void ldapsvr_set_name( LdapServer* server, const gchar *value ) {
90 g_return_if_fail( server != NULL );
91 addrcache_set_name( server->addressCache, value );
95 * Refresh internal variables to force a file read.
96 * \param server Server object.
98 void ldapsvr_force_refresh( LdapServer *server ) {
99 addrcache_refresh( server->addressCache );
103 * Return status/error code.
104 * \param server Server object.
105 * \return Status/error code.
107 gint ldapsvr_get_status( LdapServer *server ) {
108 g_return_val_if_fail( server != NULL, -1 );
109 return server->retVal;
113 * Return reference to root level folder.
114 * \param server Server object.
115 * \return Root level folder.
117 ItemFolder *ldapsvr_get_root_folder( LdapServer *server ) {
118 g_return_val_if_fail( server != NULL, NULL );
120 printf( "ldapsvr_get_root_folder/start\n" );
121 ldapsvr_print_data( server, stdout );
122 printf( "ldapsvr_get_root_folder/done\n" );
124 return addrcache_get_root_folder( server->addressCache );
128 * Test whether server data has been accessed.
129 * \param server Server object.
130 * \return <i>TRUE</i> if data was accessed.
132 gboolean ldapsvr_get_accessed( LdapServer *server ) {
133 g_return_val_if_fail( server != NULL, FALSE );
134 return server->addressCache->accessFlag;
138 * Specify that server's data whas beed accessed.
139 * \param server Server object.
140 * \param value Value for flag.
142 void ldapsvr_set_accessed( LdapServer *server, const gboolean value ) {
143 g_return_if_fail( server != NULL );
144 server->addressCache->accessFlag = value;
148 * Test whether server data has been modified.
149 * \param server Server object.
150 * \return <i>TRUE</i> if data was modified.
152 gboolean ldapsvr_get_modified( LdapServer *server ) {
153 g_return_val_if_fail( server != NULL, FALSE );
154 return server->addressCache->modified;
158 * Specify modify flag.
159 * \param server Server object.
160 * \param value Value for flag.
162 void ldapsvr_set_modified( LdapServer *server, const gboolean value ) {
163 g_return_if_fail( server != NULL );
164 server->addressCache->modified = value;
168 * Test whether data was read from server.
169 * \param server Server object.
170 * \return <i>TRUE</i> if data was read.
172 gboolean ldapsvr_get_read_flag( LdapServer *server ) {
173 g_return_val_if_fail( server != NULL, FALSE );
174 return server->addressCache->dataRead;
178 * Test whether server is to be used for dynamic searches.
179 * \param server Server object.
180 * \return <i>TRUE</i> if server is used for dynamic searches.
182 gboolean ldapsvr_get_search_flag( LdapServer *server ) {
183 g_return_val_if_fail( server != NULL, FALSE );
184 return server->searchFlag;
188 * Specify that server is to be used for dynamic searches.
189 * \param server Server object.
190 * \param value Name for server.
192 void ldapsvr_set_search_flag( LdapServer *server, const gboolean value ) {
193 g_return_if_fail( server != NULL );
194 server->searchFlag = value;
198 * Specify the reference to control data that will be used for the query. The calling
199 * module should be responsible for creating and destroying this control object.
200 * \param server Server object.
201 * \param ctl Control data.
203 void ldapsvr_set_control( LdapServer *server, LdapControl *ctl ) {
204 g_return_if_fail( server != NULL );
205 addrcache_refresh( server->addressCache );
206 server->control = ctl;
210 * Release LDAP control object.
211 * \param server Server object.
213 static void ldapsvr_release_control( LdapServer *server ) {
214 g_return_if_fail( server != NULL );
215 ldapctl_free( server->control );
216 server->control = NULL;
221 * \param server Server object.
223 void ldapsvr_free_all_query( LdapServer *server ) {
225 g_return_if_fail( server != NULL );
227 node = server->listQuery;
229 LdapQuery *qry = node->data;
232 node = g_list_next( node );
234 g_list_free( server->listQuery );
235 server->listQuery = NULL;
239 * Add query to server.
240 * \param server Server object.
241 * \param qry Query object.
243 void ldapsvr_add_query( LdapServer *server, LdapQuery *qry ) {
244 g_return_if_fail( server != NULL );
245 g_return_if_fail( qry != NULL );
247 server->listQuery = g_list_append( server->listQuery, qry );
248 qry->server = server;
252 * Free up LDAP server interface object by releasing internal memory.
253 * \param server Server object.
255 void ldapsvr_free( LdapServer *server ) {
256 g_return_if_fail( server != NULL );
258 /* Stop and cancel any queries that may be active */
259 ldapsvr_stop_all_query( server );
260 ldapsvr_cancel_all_query( server );
263 addrcache_clear( server->addressCache );
264 addrcache_free( server->addressCache );
266 /* Free LDAP control block */
267 ldapctl_free( server->control );
268 server->control = NULL;
270 /* Free all queries */
271 ldapsvr_free_all_query( server );
274 server->type = ADBOOKTYPE_NONE;
275 server->addressCache = NULL;
276 server->retVal = MGU_SUCCESS;
277 server->listQuery = NULL;
278 server->searchFlag = FALSE;
280 /* Now release LDAP object */
285 * Display object to specified stream.
286 * \param server Server object.
287 * \param stream Output stream.
289 void ldapsvr_print_data( LdapServer *server, FILE *stream ) {
293 g_return_if_fail( server != NULL );
295 fprintf( stream, "LdapServer:\n" );
296 fprintf( stream, " ret val: %d\n", server->retVal );
297 fprintf( stream, "srch flag: %s\n",
298 server->searchFlag ? "yes" : "no" );
299 if( server->control ) {
300 ldapctl_print( server->control, stream );
303 fprintf( stream, " control: NULL\n" );
305 addrcache_print( server->addressCache, stream );
306 addritem_print_item_folder( server->addressCache->rootFolder, stream );
310 node = server->listQuery;
312 LdapQuery *qry = node->data;
313 fprintf( stream, " query: %2d : %s\n", i, ADDRQUERY_NAME(qry) );
315 node = g_list_next( node );
320 * Return link list of persons.
321 * \param server Server object.
322 * \return List of persons.
324 GList *ldapsvr_get_list_person( LdapServer *server ) {
325 g_return_val_if_fail( server != NULL, NULL );
326 return addrcache_get_list_person( server->addressCache );
330 * Return link list of folders. There are no "real" folders that are returned
332 * \param server Server object.
333 * \return List of folders.
335 GList *ldapsvr_get_list_folder( LdapServer *server ) {
336 g_return_val_if_fail( server != NULL, NULL );
337 /* return addrcache_get_list_folder( server->addressCache ); */
342 * Execute specified query.
343 * \param server LDAP server.
344 * \param qry LDAP query.
346 void ldapsvr_execute_query( LdapServer *server, LdapQuery *qry ) {
347 LdapControl *ctlCopy;
349 g_return_if_fail( server != NULL );
350 g_return_if_fail( qry != NULL );
352 /* Copy server's control data to the query */
353 ctlCopy = ldapctl_create();
354 ldapctl_copy( server->control, ctlCopy );
355 ldapqry_set_control( qry, ctlCopy );
356 ldapqry_initialize();
359 /* printf( "ldapsvr_execute_query::checking query...\n" ); */
360 if( ldapqry_check_search( qry ) ) {
361 /* printf( "ldapsvr_execute_query::reading with thread...\n" ); */
362 ldapqry_read_data_th( qry );
364 if( qry->retVal == LDAPRC_SUCCESS ) {
365 printf( "ldapsvr_execute_query::SUCCESS with thread...\n" );
369 /* printf( "ldapsvr_execute_query... terminated\n" ); */
373 * Stop all queries for specified ID.
374 * \param server Server object.
375 * \param queryID Query ID to stop.
377 void ldapsvr_stop_query_id( LdapServer *server, const gint queryID ) {
379 g_return_if_fail( server != NULL );
381 node = server->listQuery;
383 LdapQuery *qry = node->data;
384 if( ADDRQUERY_ID(qry) == queryID ) {
385 /* Notify thread to stop */
386 ldapqry_set_stop_flag( qry, TRUE );
388 node = g_list_next( node );
393 * Stop all queries by notifying each thread to stop.
394 * \param server Server object.
396 void ldapsvr_stop_all_query( LdapServer *server ) {
398 g_return_if_fail( server != NULL );
400 node = server->listQuery;
402 LdapQuery *qry = node->data;
403 ldapqry_set_stop_flag( qry, TRUE );
404 node = g_list_next( node );
409 * Cancel all query threads for server.
410 * \param server Server object.
412 void ldapsvr_cancel_all_query( LdapServer *server ) {
414 g_return_if_fail( server != NULL );
416 node = server->listQuery;
418 LdapQuery *qry = node->data;
419 /* Notify thread to stop */
420 ldapqry_set_stop_flag( qry, TRUE );
421 /* Now cancel thread */
422 ldapqry_cancel( qry );
423 node = g_list_next( node );
428 * Search most recent query for specified search term. The most recent
429 * completed query is returned. If no completed query is found, the most recent
430 * incomplete is returned.
431 * \param server LdapServer.
432 * \param searchTerm Search term to locate.
433 * \return Query object, or <i>NULL</i> if none found.
435 static LdapQuery *ldapsvr_locate_query(
436 const LdapServer *server, const gchar *searchTerm )
438 LdapQuery *incomplete = NULL;
440 g_return_if_fail( server != NULL );
442 node = server->listQuery;
443 node = g_list_last( node );
444 /* Search backwards for query */
446 LdapQuery *qry = node->data;
447 if( g_utf8_collate( ADDRQUERY_SEARCHVALUE(qry), searchTerm ) == 0 ) {
448 if( qry->agedFlag ) continue;
449 if( qry->completed ) {
457 node = g_list_previous( node );
463 * Retire aged queries. Only the following queries are retired:
465 * a) Dynamic queries.
466 * b) Explicit searches that have a hidden folders.
467 * c) Locate searches that have a hidden folder.
469 * \param server LdapServer.
471 void ldapsvr_retire_query( LdapServer *server ) {
479 /* printf( "ldapsvr_retire_query\n" ); */
480 g_return_if_fail( server != NULL );
481 ctl = server->control;
482 maxAge = ctl->maxQueryAge;
484 /* Identify queries to age and move to deletion list */
486 node = server->listQuery;
488 LdapQuery *qry = node->data;
490 node = g_list_next( node );
491 folder = ADDRQUERY_FOLDER(qry);
492 if( folder == NULL ) continue;
493 if( ! folder->isHidden ) {
494 if( ADDRQUERY_SEARCHTYPE(qry) == ADDRSEARCH_EXPLICIT ) continue;
495 if( ADDRQUERY_SEARCHTYPE(qry) == ADDRSEARCH_LOCATE ) continue;
498 ldapqry_age( qry, maxAge );
499 if( qry->agedFlag ) {
500 /* Delete folder associated with query */
502 printf( "deleting folder... ::%s::\n", ADDRQUERY_NAME(qry) );
504 ldapqry_delete_folder( qry );
505 listDelete = g_list_append( listDelete, qry );
510 listQuery = server->listQuery;
513 LdapQuery *qry = node->data;
515 listQuery = g_list_remove( listQuery, qry );
518 node = g_list_next( node );
520 server->listQuery = listQuery;
522 /* Free up deletion list */
523 g_list_free( listDelete );
527 * Return results of a previous query by executing callback for each address
528 * contained in specified folder.
530 * \param folder Address book folder to process.
531 * \param req Address query request object.
533 static void ldapsvr_previous_query(
534 const ItemFolder *folder, const QueryRequest *req, AddrQueryObject *aqo )
536 AddrSearchCallbackEntry *callBack;
543 callBack = ( AddrSearchCallbackEntry * ) req->callBackEntry;
546 node = folder->listPerson;
548 AddrItemObject *aio = node->data;
549 if( aio && aio->type == ITEMTYPE_PERSON ) {
550 ItemPerson *person = node->data;
551 nodeEM = person->listEMail;
553 ItemEMail *email = nodeEM->data;
555 nodeEM = g_list_next( nodeEM );
556 listEMail = g_list_append( listEMail, email );
559 node = g_list_next( node );
561 ( callBack ) ( sender, req->queryID, listEMail, NULL );
562 /* // g_list_free( listEMail ); */
567 * Reuse search results from a previous LDAP query. If there is a query that
568 * has the same search term as specified in the query request, then the query
571 * \param server LDAP server object.
572 * \param req Address query object.
573 * \return <i>TRUE</i> if previous query was used.
575 gboolean ldapsvr_reuse_previous( const LdapServer *server, const QueryRequest *req ) {
580 g_return_val_if_fail( server != NULL, FALSE );
581 g_return_val_if_fail( req != NULL, FALSE );
583 searchTerm = req->searchTerm;
585 /* Test whether any queries for the same term exist */
586 qry = ldapsvr_locate_query( server, searchTerm );
588 /* Touch query to ensure it hangs around for a bit longer */
589 ldapqry_touch( qry );
590 folder = ADDRQUERY_FOLDER(qry);
592 ldapsvr_previous_query( folder, req, ADDRQUERY_OBJECT(qry) );
600 * Construct a new LdapQuery object that will be used to perform an dynamic
603 * \param server LdapServer.
604 * \param req Query request.
605 * \return LdapQuery object, or <i>NULL</i> if none created.
607 LdapQuery *ldapsvr_new_dynamic_search( LdapServer *server, QueryRequest *req )
614 g_return_val_if_fail( server != NULL, NULL );
615 g_return_val_if_fail( req != NULL, NULL );
617 /* Retire any aged queries */
618 /* // ldapsvr_retire_query( server ); */
620 /* Name of folder and query */
621 searchTerm = req->searchTerm;
622 name = g_strdup_printf( "Search '%s'", searchTerm );
624 /* Create a folder for the search results */
625 folder = addrcache_add_new_folder( server->addressCache, NULL );
626 addritem_folder_set_name( folder, name );
627 addritem_folder_set_remarks( folder, "" );
629 /* Construct a query */
630 qry = ldapqry_create();
631 ldapqry_set_query_id( qry, req->queryID );
632 ldapqry_set_search_value( qry, searchTerm );
633 ldapqry_set_search_type( qry, ADDRSEARCH_DYNAMIC );
634 ldapqry_set_callback_entry( qry, req->callBackEntry );
635 ldapqry_set_callback_end( qry, req->callBackEnd );
637 /* Specify folder type and back reference */
638 ADDRQUERY_FOLDER(qry) = folder;
639 folder->folderType = ADDRFOLDER_QUERY_RESULTS;
640 folder->folderData = ( gpointer ) qry;
641 folder->isHidden = TRUE;
644 ldapqry_set_name( qry, name );
647 /* Add query to request */
648 qryreq_add_query( req, ADDRQUERY_OBJECT(qry) );
650 /* Now start the search */
651 ldapsvr_add_query( server, qry );
657 * Construct a new LdapQuery object that will be used to perform an explicit
660 * \param server LdapServer.
661 * \param req Query request.
662 * \param folder Folder that will be used to contain search results.
663 * \return LdapQuery object, or <i>NULL</i> if none created.
665 LdapQuery *ldapsvr_new_explicit_search(
666 LdapServer *server, QueryRequest *req, ItemFolder *folder )
672 g_return_val_if_fail( server != NULL, NULL );
673 g_return_val_if_fail( req != NULL, NULL );
674 g_return_val_if_fail( folder != NULL, NULL );
676 /* Retire any aged queries */
677 /* // ldapsvr_retire_query( server ); */
680 searchTerm = req->searchTerm;
681 name = g_strdup_printf( "Explicit search for '%s'", searchTerm );
683 /* Construct a query */
684 qry = ldapqry_create();
685 ldapqry_set_query_id( qry, req->queryID );
686 ldapqry_set_name( qry, name );
687 ldapqry_set_search_value( qry, searchTerm );
688 ldapqry_set_search_type( qry, ADDRSEARCH_EXPLICIT );
689 ldapqry_set_callback_end( qry, req->callBackEnd );
690 ldapqry_set_callback_entry( qry, req->callBackEntry );
692 /* Specify folder type and back reference */
693 ADDRQUERY_FOLDER(qry) = folder;
694 folder->folderType = ADDRFOLDER_QUERY_RESULTS;
695 folder->folderData = ( gpointer ) qry;
698 ldapsvr_add_query( server, qry );
700 /* Set up query request */
701 qryreq_add_query( req, ADDRQUERY_OBJECT(qry) );
708 #endif /* USE_LDAP */