2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 2001-2006 Match Grun and the Sylpheed-Claws team
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21 * Functions necessary to access LDIF files (LDAP Data Interchange Format
26 #include <glib/gi18n.h>
33 #include "addrcache.h"
38 #define LDIF_SEP_TAG ':'
39 #define LDIF_LANG_TAG ';'
43 * \return Initialized LDIF file object.
45 LdifFile *ldif_create() {
47 ldifFile = g_new0( LdifFile, 1 );
48 ldifFile->path = NULL;
49 ldifFile->file = NULL;
50 ldifFile->bufptr = ldifFile->buffer;
51 ldifFile->hashFields = g_hash_table_new( g_str_hash, g_str_equal );
52 ldifFile->tempList = NULL;
53 ldifFile->dirtyFlag = TRUE;
54 ldifFile->accessFlag = FALSE;
55 ldifFile->retVal = MGU_SUCCESS;
56 ldifFile->cbProgress = NULL;
57 ldifFile->importCount = 0;
62 * Specify full file specification of LDIF file.
63 * \param ldifFile LDIF import control object.
64 * \param value Value of access flag.
66 void ldif_set_file( LdifFile *ldifFile, const gchar *value ) {
67 g_return_if_fail( ldifFile != NULL );
69 if( ldifFile->path ) {
70 if( strcmp( ldifFile->path, value ) != 0 )
71 ldifFile->dirtyFlag = TRUE;
74 ldifFile->dirtyFlag = TRUE;
76 ldifFile->path = mgu_replace_string( ldifFile->path, value );
77 g_strstrip( ldifFile->path );
78 ldifFile->importCount = 0;
82 * Set the file access indicator.
83 * \param ldifFile LDIF import control object.
84 * \param value File specification.
86 void ldif_set_accessed( LdifFile *ldifFile, const gboolean value ) {
87 g_return_if_fail( ldifFile != NULL );
88 ldifFile->accessFlag = value;
92 * Register a progress indicator callback function.
94 * \param ldifFile LDIF import control object.
95 * \param func Function to be called. When called, the function will be
96 * passed the following arguments:
99 * <li>LdifFile object,</li>
100 * <li>File size (long),</li>
101 * <li>Current position (long)</li>
104 void ldif_set_callback( LdifFile *ldifFile, void *func ) {
105 ldifFile->cbProgress = func;
109 * Create field record object.
110 * \return Initialized LDIF field object.
112 static Ldif_FieldRec *ldif_create_fieldrec( const gchar *field ) {
113 Ldif_FieldRec *rec = g_new0( Ldif_FieldRec, 1 );
114 rec->tagName = g_strdup( field );
115 rec->userName = NULL;
116 rec->reserved = FALSE;
117 rec->selected = FALSE;
122 * Free field record object.
123 * \param rec LDIF field object.
125 static void ldif_free_fieldrec( Ldif_FieldRec *rec ) {
127 g_free( rec->tagName );
128 g_free( rec->userName );
130 rec->userName = NULL;
131 rec->reserved = FALSE;
132 rec->selected = FALSE;
138 * Set user name for field record.
139 * \param rec LDIF field object.
140 * \param value User name to set. Note that reserved fields cannot be
143 void ldif_field_set_name( Ldif_FieldRec *rec, const gchar *value ) {
144 g_return_if_fail( rec != NULL );
146 if( ! rec->reserved ) {
147 rec->userName = mgu_replace_string( rec->userName, value );
148 g_strstrip( rec->userName );
153 * Specify selection for field record.
154 * \param rec LDIF field object.
155 * \param value Set to <i>TRUE</i> to select field. Note that reserved
156 * fields cannot be unselected.
158 void ldif_field_set_selected( Ldif_FieldRec *rec, const gboolean value ) {
159 g_return_if_fail( rec != NULL );
161 if( ! rec->reserved ) {
162 rec->selected = value;
167 * Toggle selection for field record. Note that reserved fields cannot be
169 * \param rec LDIF field object.
171 void ldif_field_toggle( Ldif_FieldRec *rec ) {
172 g_return_if_fail( rec != NULL );
174 if( ! rec->reserved ) {
175 rec->selected = !rec->selected;
180 * Free hash table entry visitor function.
182 * \param value Value (the LDIF field record).
183 * \param data User data.
184 * \return <code>-1</code>.
186 static gint ldif_hash_free_vis( gpointer key, gpointer value, gpointer data ) {
187 ldif_free_fieldrec( ( Ldif_FieldRec * ) value );
194 * Free up object by releasing internal memory.
195 * \param ldifFile LDIF import control object.
197 void ldif_free( LdifFile *ldifFile ) {
198 g_return_if_fail( ldifFile != NULL );
201 if( ldifFile->file ) fclose( ldifFile->file );
203 /* Free internal stuff */
204 g_free( ldifFile->path );
206 /* Free field list */
207 g_hash_table_foreach_remove( ldifFile->hashFields, ldif_hash_free_vis, NULL );
208 g_hash_table_destroy( ldifFile->hashFields );
209 ldifFile->hashFields = NULL;
212 ldifFile->file = NULL;
213 ldifFile->path = NULL;
214 ldifFile->retVal = MGU_SUCCESS;
215 ldifFile->tempList = NULL;
216 ldifFile->dirtyFlag = FALSE;
217 ldifFile->accessFlag = FALSE;
218 ldifFile->cbProgress = NULL;
220 /* Now release file object */
225 * Display field record.
226 * \param rec LDIF field object.
227 * \param stream File output stream.
229 void ldif_print_fieldrec( Ldif_FieldRec *rec, FILE *stream ) {
230 fprintf( stream, "\ttag:\t%s", rec->reserved ? "yes" : "no" );
231 fprintf( stream, "\t%s", rec->selected ? "yes" : "no" );
232 fprintf( stream, "\t:%s:\t:%s:\n", rec->userName, rec->tagName );
236 * Display field record.
238 * \param value Value (the LDIF field record).
239 * \param data User data (file output stream).
242 static void ldif_print_file_vis( gpointer key, gpointer value, gpointer data ) {
243 Ldif_FieldRec *rec = value;
245 ldif_print_fieldrec( rec, stream );
249 * Display object to specified stream.
250 * \param ldifFile LDIF import control object.
251 * \param stream File output stream.
253 void ldif_print_file( LdifFile *ldifFile, FILE *stream ) {
254 g_return_if_fail( ldifFile != NULL );
255 fprintf( stream, "LDIF File:\n" );
256 fprintf( stream, "file spec: '%s'\n", ldifFile->path );
257 fprintf( stream, " ret val: %d\n", ldifFile->retVal );
258 fprintf( stream, " fields: {\n" );
259 g_hash_table_foreach( ldifFile->hashFields, ldif_print_file_vis, stream );
260 fprintf( stream, "} ---\n" );
264 * Open file for read.
265 * \param ldifFile LDIF import control object.
266 * \return <i>TRUE</i> if file opened successfully.
268 static gint ldif_open_file( LdifFile* ldifFile ) {
269 /* printf( "Opening file\n" ); */
270 if( ldifFile->path ) {
271 ldifFile->file = g_fopen( ldifFile->path, "rb" );
272 if( ! ldifFile->file ) {
273 /* printf( "can't open %s\n", ldifFile->path ); */
274 ldifFile->retVal = MGU_OPEN_FILE;
275 return ldifFile->retVal;
279 /* printf( "file not specified\n" ); */
280 ldifFile->retVal = MGU_NO_FILE;
281 return ldifFile->retVal;
284 /* Setup a buffer area */
285 ldifFile->buffer[0] = '\0';
286 ldifFile->bufptr = ldifFile->buffer;
287 ldifFile->retVal = MGU_SUCCESS;
288 return ldifFile->retVal;
293 * \param ldifFile LDIF import control object.
295 static void ldif_close_file( LdifFile *ldifFile ) {
296 g_return_if_fail( ldifFile != NULL );
297 if( ldifFile->file ) fclose( ldifFile->file );
298 ldifFile->file = NULL;
302 * Read line of text from file.
303 * \param ldifFile LDIF import control object.
304 * \return ptr to buffer where line starts.
306 static gchar *ldif_get_line( LdifFile *ldifFile ) {
307 gchar buf[ LDIFBUFSIZE ];
311 if( feof( ldifFile->file ) )
314 while( i < LDIFBUFSIZE-1 ) {
315 ch = fgetc( ldifFile->file );
316 if( ch == '\0' || ch == EOF ) {
317 if( i == 0 ) return NULL;
320 #if HAVE_DOSISH_SYSTEM
332 /* Return a copy of buffer */
333 return g_strdup( buf );
337 * Parse tag name from line buffer.
338 * \param line Buffer.
339 * \param flag64 Base-64 encoder flag.
340 * \return Buffer containing the tag name, or NULL if no delimiter char found.
341 * If a double delimiter (::) is found, flag64 is set.
343 static gchar *ldif_get_tagname( char* line, gboolean *flag64 ) {
350 /* Check for language tag */
351 if( *lptr == LDIF_LANG_TAG ) {
352 if( sptr == NULL ) sptr = lptr;
355 /* Check for delimiter */
356 if( *lptr == LDIF_SEP_TAG ) {
364 /* Base-64 encoding? */
365 if( * ++lptr == LDIF_SEP_TAG ) *flag64 = TRUE;
367 tag = g_strndup( line, len+1 );
377 * Parse tag value from line buffer.
378 * \param line Buffer.
379 * \return Buffer containing the tag value. Empty string is returned if
380 * no delimiter char found.
382 static gchar *ldif_get_tagvalue( gchar* line ) {
388 for( lptr = line; *lptr; lptr++ ) {
389 if( *lptr == LDIF_SEP_TAG ) {
395 if( *start == LDIF_SEP_TAG ) start++;
397 value = g_strndup( start, len+1 );
401 /* Ensure that we get an empty string */
402 value = g_strndup( "", 1 );
409 * Parsed address data record.
411 typedef struct _Ldif_ParsedRec_ Ldif_ParsedRec;
412 struct _Ldif_ParsedRec_ {
423 * User attribute data record.
425 typedef struct _Ldif_UserAttr_ Ldif_UserAttr;
426 struct _Ldif_UserAttr_ {
432 * Build an address list entry and append to list of address items in the
433 * address cache. Name is formatted as "<first-name> <last-name>".
434 * \param ldifFile LDIF import control object.
435 * \param rec LDIF field object.
436 * \param cache Address cache to be populated with data.
438 static void ldif_build_items(
439 LdifFile *ldifFile, Ldif_ParsedRec *rec, AddressCache *cache )
444 gchar *firstName = NULL, *lastName = NULL, *fullName = NULL;
445 gchar *nickName = NULL;
446 gint iLen = 0, iLenT = 0;
450 nodeAddress = rec->listAddress;
451 if( nodeAddress == NULL ) return;
453 /* Find longest first name in list */
454 nodeFirst = rec->listFName;
456 if( firstName == NULL ) {
457 firstName = nodeFirst->data;
458 iLen = strlen( firstName );
461 if( ( iLenT = strlen( nodeFirst->data ) ) > iLen ) {
462 firstName = nodeFirst->data;
466 nodeFirst = g_slist_next( nodeFirst );
470 if( rec->listLName ) {
471 lastName = rec->listLName->data;
476 fullName = g_strdup_printf(
477 "%s %s", firstName, lastName );
480 fullName = g_strdup_printf( "%s", firstName );
485 fullName = g_strdup_printf( "%s", lastName );
489 if (!fullName || strlen(fullName) == 0) {
493 fullName = g_strdup(rec->listCName->data);
497 g_strchug( fullName ); g_strchomp( fullName );
500 if( rec->listNName ) {
501 nickName = rec->listNName->data;
504 person = addritem_create_item_person();
505 addritem_person_set_common_name( person, fullName );
506 addritem_person_set_first_name( person, firstName );
507 addritem_person_set_last_name( person, lastName );
508 addritem_person_set_nick_name( person, nickName );
509 addrcache_id_person( cache, person );
510 addrcache_add_person( cache, person );
511 ++ldifFile->importCount;
513 /* Add address item */
514 while( nodeAddress ) {
515 email = addritem_create_item_email();
516 addritem_email_set_address( email, nodeAddress->data );
517 addrcache_id_email( cache, email );
518 addrcache_person_add_email( cache, person, email );
519 nodeAddress = g_slist_next( nodeAddress );
522 fullName = firstName = lastName = NULL;
524 /* Add user attributes */
525 nodeAttr = rec->userAttr;
527 Ldif_UserAttr *attr = nodeAttr->data;
528 UserAttribute *attrib = addritem_create_attribute();
529 addritem_attrib_set_name( attrib, attr->name );
530 addritem_attrib_set_value( attrib, attr->value );
531 addritem_person_add_attribute( person, attrib );
532 nodeAttr = g_slist_next( nodeAttr );
538 * Add selected field as user attribute.
539 * \param rec LDIF field object.
540 * \param tagName LDIF tag name.
541 * \param tagValue Data value.
542 * \param hashField Hash table to populate.
544 static void ldif_add_user_attr(
545 Ldif_ParsedRec *rec, gchar *tagName, gchar *tagValue,
546 GHashTable *hashField )
548 Ldif_FieldRec *fld = NULL;
549 Ldif_UserAttr *attr = NULL;
552 fld = g_hash_table_lookup( hashField, tagName );
554 if( ! fld->selected ) return;
557 if( fld->userName ) {
558 name = fld->userName;
560 attr = g_new0( Ldif_UserAttr, 1 );
561 attr->name = g_strdup( name );
562 attr->value = g_strdup( tagValue );
563 rec->userAttr = g_slist_append( rec->userAttr, attr );
568 * Add value to parsed data.
569 * \param rec LDIF field object.
570 * \param tagName LDIF tag name.
571 * \param tagValue Data value.
572 * \param hashField Hash table to populate.
574 static void ldif_add_value(
575 Ldif_ParsedRec *rec, gchar *tagName, gchar *tagValue,
576 GHashTable *hashField )
580 nm = g_strdup( tagName );
583 val = g_strdup( tagValue );
586 val = g_strdup( "" );
590 if( g_utf8_collate( nm, LDIF_TAG_COMMONNAME ) == 0 ) {
591 rec->listCName = g_slist_append( rec->listCName, val );
593 else if( g_utf8_collate( nm, LDIF_TAG_FIRSTNAME ) == 0 ) {
594 rec->listFName = g_slist_append( rec->listFName, val );
596 else if( g_utf8_collate( nm, LDIF_TAG_LASTNAME ) == 0 ) {
597 rec->listLName = g_slist_append( rec->listLName, val );
599 else if( g_utf8_collate( nm, LDIF_TAG_NICKNAME ) == 0 ) {
600 rec->listNName = g_slist_append( rec->listNName, val );
602 else if( g_utf8_collate( nm, LDIF_TAG_EMAIL ) == 0 ) {
603 rec->listAddress = g_slist_append( rec->listAddress, val );
606 /* Add field as user attribute */
607 ldif_add_user_attr( rec, tagName, tagValue, hashField );
613 * Clear parsed data record.
614 * \param rec LDIF field object.
616 static void ldif_clear_rec( Ldif_ParsedRec *rec ) {
619 /* Free up user attributes */
620 list = rec->userAttr;
622 Ldif_UserAttr *attr = list->data;
623 g_free( attr->name );
624 g_free( attr->value );
626 list = g_slist_next( list );
628 g_slist_free( rec->userAttr );
630 g_slist_free( rec->listCName );
631 g_slist_free( rec->listFName );
632 g_slist_free( rec->listLName );
633 g_slist_free( rec->listNName );
634 g_slist_free( rec->listAddress );
635 g_slist_free( rec->listID );
637 rec->userAttr = NULL;
638 rec->listCName = NULL;
639 rec->listFName = NULL;
640 rec->listLName = NULL;
641 rec->listNName = NULL;
642 rec->listAddress = NULL;
647 * Read file data into address cache.
648 * Note that one LDIF record identifies one entity uniquely with the
649 * distinguished name (dn) tag. Each person can have multiple E-Mail
650 * addresses. Also, each person can have many common name (cn) tags.
652 * \param ldifFile LDIF import control object.
653 * \param cache Address cache to be populated with data.
655 static void ldif_read_file( LdifFile *ldifFile, AddressCache *cache ) {
656 gchar *tagName = NULL, *tagValue = NULL;
657 gchar *lastTag = NULL, *fullValue = NULL;
658 GSList *listValue = NULL;
659 gboolean flagEOF = FALSE, flagEOR = FALSE;
660 gboolean flag64 = FALSE, last64 = FALSE;
664 GHashTable *hashField;
666 hashField = ldifFile->hashFields;
667 rec = g_new0( Ldif_ParsedRec, 1 );
668 ldif_clear_rec( rec );
670 /* Find EOF for progress indicator */
671 fseek( ldifFile->file, 0L, SEEK_END );
672 posEnd = ftell( ldifFile->file );
673 fseek( ldifFile->file, 0L, SEEK_SET );
676 gchar *line = ldif_get_line( ldifFile );
678 posCur = ftell( ldifFile->file );
679 if( ldifFile->cbProgress ) {
680 /* Call progress indicator */
681 ( ldifFile->cbProgress ) ( ldifFile, & posEnd, & posCur );
686 flagEOF = flagEOR = TRUE;
688 else if( *line == '\0' ) {
693 /* EOR, Output address data */
696 fullValue = mgu_list_coalesce( listValue );
697 if (fullValue && last64) {
698 gchar *out = g_malloc(strlen(fullValue));
700 if ((len = base64_decode(out, fullValue,
701 strlen(fullValue))) >= 0) {
704 fullValue[len] = '\0';
708 /* Base-64 encoded data */
711 ldif_dump_b64( fullValue );
715 ldif_add_value( rec, lastTag, fullValue, hashField );
716 /* ldif_print_record( rec, stdout ); */
717 ldif_build_items( ldifFile, rec, cache );
718 ldif_clear_rec( rec );
720 mgu_free_list( listValue );
729 /* Continuation line */
730 listValue = g_slist_append(
731 listValue, g_strdup( line+1 ) );
733 else if( *line == '=' ) {
734 /* Base-64 encoded continuation field */
735 listValue = g_slist_append(
736 listValue, g_strdup( line ) );
740 tagName = ldif_get_tagname( line, &flag64 );
742 tagValue = ldif_get_tagvalue( line );
747 mgu_list_coalesce( listValue );
748 if (fullValue && last64) {
749 gchar *out = g_malloc(strlen(fullValue));
751 if ((len = base64_decode(out, fullValue,
752 strlen(fullValue))) >= 0) {
755 fullValue[len] = '\0';
759 /* Base-64 encoded data */
762 ldif_dump_b64( fullValue );
767 rec, lastTag, fullValue,
770 mgu_free_list( listValue );
776 lastTag = g_strdup( tagName );
777 listValue = g_slist_append(
779 g_strdup( tagValue ) );
791 ldif_clear_rec( rec );
794 mgu_free_list( listValue );
798 * Add list of field names to hash table.
799 * \param table Hashtable.
800 * \param list List of fields.
802 static void ldif_hash_add_list( GHashTable *table, GSList *list ) {
805 /* mgu_print_list( list, stdout ); */
807 gchar *tag = node->data;
808 if( ! g_hash_table_lookup( table, tag ) ) {
809 Ldif_FieldRec *rec = NULL;
810 gchar *key = g_strdup( tag );
812 rec = ldif_create_fieldrec( tag );
813 if( g_utf8_collate( tag, LDIF_TAG_DN ) == 0 ) {
814 rec->reserved = rec->selected = TRUE;
815 rec->userName = g_strdup( "dn" );
817 else if( g_utf8_collate( tag, LDIF_TAG_COMMONNAME ) == 0 ) {
818 rec->reserved = rec->selected = TRUE;
819 rec->userName = g_strdup( _( "Display Name" ) );
821 else if( g_utf8_collate( tag, LDIF_TAG_FIRSTNAME ) == 0 ) {
822 rec->reserved = rec->selected = TRUE;
823 rec->userName = g_strdup( _( "First Name" ) );
825 else if( g_utf8_collate( tag, LDIF_TAG_LASTNAME ) == 0 ) {
826 rec->reserved = rec->selected = TRUE;
827 rec->userName = g_strdup( _( "Last Name" ) );
829 else if( g_utf8_collate( tag, LDIF_TAG_NICKNAME ) == 0 ) {
830 rec->reserved = rec->selected = TRUE;
831 rec->userName = g_strdup( _( "Nick Name" ) );
833 else if( g_utf8_collate( tag, LDIF_TAG_EMAIL ) == 0 ) {
834 rec->reserved = rec->selected = TRUE;
835 rec->userName = g_strdup( _( "Email Address" ) );
837 g_hash_table_insert( table, key, rec );
839 node = g_slist_next( node );
844 * Sorted list comparison function.
845 * \param ptr1 First field.
846 * \param ptr2 Second field.
847 * \return <code>-1, 0, +1</code> if first record less than, equal,
848 * greater than second.
850 static gint ldif_field_compare( gconstpointer ptr1, gconstpointer ptr2 ) {
851 const Ldif_FieldRec *rec1 = ptr1;
852 const Ldif_FieldRec *rec2 = ptr2;
854 if( rec1->reserved ) {
855 if( ! rec2->reserved ) {
860 if( rec2->reserved ) {
864 return g_utf8_collate( rec1->tagName, rec2->tagName );
868 * Append hash table entry to list - visitor function.
870 * \param value Data value.
871 * \param data User data (the LDIF import control object).
873 static void ldif_hash2list_vis( gpointer key, gpointer value, gpointer data ) {
874 LdifFile *ldf = data;
876 g_list_insert_sorted( ldf->tempList, value, ldif_field_compare );
880 * Read tag names for file data.
881 * \param ldifFile LDIF import control object.
883 static void ldif_read_tag_list( LdifFile *ldifFile ) {
884 gchar *tagName = NULL;
885 GSList *listTags = NULL;
886 gboolean flagEOF = FALSE, flagEOR = FALSE, flagMail = FALSE;
887 gboolean flag64 = FALSE;
891 /* Clear hash table */
892 g_hash_table_foreach_remove(
893 ldifFile->hashFields, ldif_hash_free_vis, NULL );
895 /* Find EOF for progress indicator */
896 fseek( ldifFile->file, 0L, SEEK_END );
897 posEnd = ftell( ldifFile->file );
898 fseek( ldifFile->file, 0L, SEEK_SET );
902 gchar *line = ldif_get_line( ldifFile );
903 posCur = ftell( ldifFile->file );
904 if( ldifFile->cbProgress ) {
905 /* Call progress indicator */
906 ( ldifFile->cbProgress ) ( ldifFile, & posEnd, & posCur );
911 flagEOF = flagEOR = TRUE;
913 else if( *line == '\0' ) {
918 /* EOR, Output address data */
919 /* Save field list to hash table */
922 ldifFile->hashFields, listTags );
924 mgu_free_list( listTags );
931 /* Continuation line */
933 else if( *line == '=' ) {
934 /* Base-64 encoded continuation field */
938 tagName = ldif_get_tagname( line, &flag64 );
940 /* Add tag to list */
941 listTags = g_slist_append( listTags, tagName );
944 tagName, LDIF_TAG_EMAIL ) == 0 )
955 mgu_free_list( listTags );
960 * Read file into list. Main entry point
961 * \param ldifFile LDIF import control object.
962 * \param cache Address cache to load.
963 * \return Status code.
965 gint ldif_import_data( LdifFile *ldifFile, AddressCache *cache ) {
966 g_return_val_if_fail( ldifFile != NULL, MGU_BAD_ARGS );
967 ldifFile->retVal = MGU_SUCCESS;
968 addrcache_clear( cache );
969 cache->dataRead = FALSE;
970 ldif_open_file( ldifFile );
971 if( ldifFile->retVal == MGU_SUCCESS ) {
972 /* Read data into the cache */
973 ldif_read_file( ldifFile, cache );
974 ldif_close_file( ldifFile );
977 cache->modified = FALSE;
978 cache->dataRead = TRUE;
980 return ldifFile->retVal;
984 * Process entire file reading list of unique fields. List of fields may be
985 * accessed with the <code>ldif_get_fieldlist()</code> function.
986 * \param ldifFile LDIF import control object.
987 * \return Status code.
989 gint ldif_read_tags( LdifFile *ldifFile ) {
990 g_return_val_if_fail( ldifFile != NULL, MGU_BAD_ARGS );
991 ldifFile->retVal = MGU_SUCCESS;
992 if( ldifFile->dirtyFlag ) {
993 ldif_open_file( ldifFile );
994 if( ldifFile->retVal == MGU_SUCCESS ) {
995 /* Read data into the cache */
996 ldif_read_tag_list( ldifFile );
997 ldif_close_file( ldifFile );
998 ldifFile->dirtyFlag = FALSE;
999 ldifFile->accessFlag = TRUE;
1002 return ldifFile->retVal;
1006 * Return list of fields for LDIF file.
1007 * \param ldifFile LDIF import control object.
1008 * \return Linked list of <code>Ldif_FieldRec</code> objects. This list may be
1009 * <code>g_free()</code>. Note that the objects in the list should not
1010 * be freed since they refer to objects inside the internal cache.
1011 * These objects will be freed when LDIF file object is freed.
1013 GList *ldif_get_fieldlist( LdifFile *ldifFile ) {
1016 g_return_val_if_fail( ldifFile != NULL, NULL );
1017 if( ldifFile->hashFields ) {
1018 ldifFile->tempList = NULL;
1019 g_hash_table_foreach( ldifFile->hashFields, ldif_hash2list_vis, ldifFile );
1020 list = ldifFile->tempList;
1021 ldifFile->tempList = NULL;
1027 * Output LDIF name-value pair to stream. Only non-empty names and values will
1028 * be output to file.
1029 * \param stream File output stream.
1031 * \param value Data value.
1032 * \return <i>TRUE</i> if data output.
1034 gboolean ldif_write_value( FILE *stream, const gchar *name, const gchar *value ) {
1035 if( name == NULL ) return FALSE;
1036 if( value == NULL ) return FALSE;
1037 if( strlen( name ) < 1 ) return FALSE;
1038 if( strlen( value ) < 1 ) return FALSE;
1039 fprintf( stream, "%s: ", name );
1040 fprintf( stream, "%s\n", value );
1045 * Output LDIF End of Record to stream.
1046 * \param stream File output stream.
1047 * \return <i>TRUE</i> if data output.
1049 void ldif_write_eor( FILE *stream ) {
1050 /* Simple but caller should not need to know how to end record. */
1051 fprintf( stream, "\n" );
1055 * ============================================================================
1057 * ============================================================================