2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 2001-2007 Match Grun and the Claws Mail 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 * Create field record object.
93 * \return Initialized LDIF field object.
95 static Ldif_FieldRec
*ldif_create_fieldrec( const gchar
*field
) {
96 Ldif_FieldRec
*rec
= g_new0( Ldif_FieldRec
, 1 );
97 rec
->tagName
= g_strdup( field
);
99 rec
->reserved
= FALSE
;
100 rec
->selected
= FALSE
;
105 * Free field record object.
106 * \param rec LDIF field object.
108 static void ldif_free_fieldrec( Ldif_FieldRec
*rec
) {
110 g_free( rec
->tagName
);
111 g_free( rec
->userName
);
113 rec
->userName
= NULL
;
114 rec
->reserved
= FALSE
;
115 rec
->selected
= FALSE
;
121 * Set user name for field record.
122 * \param rec LDIF field object.
123 * \param value User name to set. Note that reserved fields cannot be
126 void ldif_field_set_name( Ldif_FieldRec
*rec
, const gchar
*value
) {
127 g_return_if_fail( rec
!= NULL
);
129 if( ! rec
->reserved
) {
130 rec
->userName
= mgu_replace_string( rec
->userName
, value
);
131 g_strstrip( rec
->userName
);
136 * Specify selection for field record.
137 * \param rec LDIF field object.
138 * \param value Set to <i>TRUE</i> to select field. Note that reserved
139 * fields cannot be unselected.
141 void ldif_field_set_selected( Ldif_FieldRec
*rec
, const gboolean value
) {
142 g_return_if_fail( rec
!= NULL
);
144 if( ! rec
->reserved
) {
145 rec
->selected
= value
;
150 * Toggle selection for field record. Note that reserved fields cannot be
152 * \param rec LDIF field object.
154 void ldif_field_toggle( Ldif_FieldRec
*rec
) {
155 g_return_if_fail( rec
!= NULL
);
157 if( ! rec
->reserved
) {
158 rec
->selected
= !rec
->selected
;
163 * Free hash table entry visitor function.
165 * \param value Value (the LDIF field record).
166 * \param data User data.
167 * \return <code>-1</code>.
169 static gint
ldif_hash_free_vis( gpointer key
, gpointer value
, gpointer data
) {
170 ldif_free_fieldrec( ( Ldif_FieldRec
* ) value
);
177 * Free up object by releasing internal memory.
178 * \param ldifFile LDIF import control object.
180 void ldif_free( LdifFile
*ldifFile
) {
181 g_return_if_fail( ldifFile
!= NULL
);
184 if( ldifFile
->file
) fclose( ldifFile
->file
);
186 /* Free internal stuff */
187 g_free( ldifFile
->path
);
189 /* Free field list */
190 g_hash_table_foreach_remove( ldifFile
->hashFields
, ldif_hash_free_vis
, NULL
);
191 g_hash_table_destroy( ldifFile
->hashFields
);
192 ldifFile
->hashFields
= NULL
;
195 ldifFile
->file
= NULL
;
196 ldifFile
->path
= NULL
;
197 ldifFile
->retVal
= MGU_SUCCESS
;
198 ldifFile
->tempList
= NULL
;
199 ldifFile
->dirtyFlag
= FALSE
;
200 ldifFile
->accessFlag
= FALSE
;
201 ldifFile
->cbProgress
= NULL
;
203 /* Now release file object */
208 * Open file for read.
209 * \param ldifFile LDIF import control object.
210 * \return <i>TRUE</i> if file opened successfully.
212 static gint
ldif_open_file( LdifFile
* ldifFile
) {
213 /* printf( "Opening file\n" ); */
214 if( ldifFile
->path
) {
215 ldifFile
->file
= g_fopen( ldifFile
->path
, "rb" );
216 if( ! ldifFile
->file
) {
217 /* printf( "can't open %s\n", ldifFile->path ); */
218 ldifFile
->retVal
= MGU_OPEN_FILE
;
219 return ldifFile
->retVal
;
223 /* printf( "file not specified\n" ); */
224 ldifFile
->retVal
= MGU_NO_FILE
;
225 return ldifFile
->retVal
;
228 /* Setup a buffer area */
229 ldifFile
->buffer
[0] = '\0';
230 ldifFile
->bufptr
= ldifFile
->buffer
;
231 ldifFile
->retVal
= MGU_SUCCESS
;
232 return ldifFile
->retVal
;
237 * \param ldifFile LDIF import control object.
239 static void ldif_close_file( LdifFile
*ldifFile
) {
240 g_return_if_fail( ldifFile
!= NULL
);
241 if( ldifFile
->file
) fclose( ldifFile
->file
);
242 ldifFile
->file
= NULL
;
246 * Read line of text from file.
247 * \param ldifFile LDIF import control object.
248 * \return ptr to buffer where line starts.
250 static gchar
*ldif_get_line( LdifFile
*ldifFile
) {
251 gchar buf
[ LDIFBUFSIZE
];
255 if( feof( ldifFile
->file
) )
258 while( i
< LDIFBUFSIZE
-1 ) {
259 ch
= fgetc( ldifFile
->file
);
260 if (ferror( ldifFile
->file
))
261 ldifFile
->retVal
= MGU_ERROR_READ
;
262 if( ch
== '\0' || ch
== EOF
) {
263 if( i
== 0 ) return NULL
;
266 #if HAVE_DOSISH_SYSTEM
278 /* Return a copy of buffer */
279 return g_strdup( buf
);
283 * Parse tag name from line buffer.
284 * \param line Buffer.
285 * \param flag64 Base-64 encoder flag.
286 * \return Buffer containing the tag name, or NULL if no delimiter char found.
287 * If a double delimiter (::) is found, flag64 is set.
289 static gchar
*ldif_get_tagname( char* line
, gboolean
*flag64
) {
296 /* Check for language tag */
297 if( *lptr
== LDIF_LANG_TAG
) {
298 if( sptr
== NULL
) sptr
= lptr
;
301 /* Check for delimiter */
302 if( *lptr
== LDIF_SEP_TAG
) {
310 /* Base-64 encoding? */
311 if( * ++lptr
== LDIF_SEP_TAG
) *flag64
= TRUE
;
313 tag
= g_strndup( line
, len
+1 );
323 * Parse tag value from line buffer.
324 * \param line Buffer.
325 * \return Buffer containing the tag value. Empty string is returned if
326 * no delimiter char found.
328 static gchar
*ldif_get_tagvalue( gchar
* line
) {
334 for( lptr
= line
; *lptr
; lptr
++ ) {
335 if( *lptr
== LDIF_SEP_TAG
) {
341 if( *start
== LDIF_SEP_TAG
) start
++;
343 value
= g_strndup( start
, len
+1 );
347 /* Ensure that we get an empty string */
348 value
= g_strndup( "", 1 );
355 * Parsed address data record.
357 typedef struct _Ldif_ParsedRec_ Ldif_ParsedRec
;
358 struct _Ldif_ParsedRec_
{
369 * User attribute data record.
371 typedef struct _Ldif_UserAttr_ Ldif_UserAttr
;
372 struct _Ldif_UserAttr_
{
378 * Build an address list entry and append to list of address items in the
379 * address cache. Name is formatted as "<first-name> <last-name>".
380 * \param ldifFile LDIF import control object.
381 * \param rec LDIF field object.
382 * \param cache Address cache to be populated with data.
384 static void ldif_build_items(
385 LdifFile
*ldifFile
, Ldif_ParsedRec
*rec
, AddressCache
*cache
)
390 gchar
*firstName
= NULL
, *lastName
= NULL
, *fullName
= NULL
;
391 gchar
*nickName
= NULL
;
392 gint iLen
= 0, iLenT
= 0;
396 nodeAddress
= rec
->listAddress
;
397 if( nodeAddress
== NULL
) return;
399 /* Find longest first name in list */
400 nodeFirst
= rec
->listFName
;
402 if( firstName
== NULL
) {
403 firstName
= nodeFirst
->data
;
404 iLen
= strlen( firstName
);
407 if( ( iLenT
= strlen( nodeFirst
->data
) ) > iLen
) {
408 firstName
= nodeFirst
->data
;
412 nodeFirst
= g_slist_next( nodeFirst
);
416 if( rec
->listLName
) {
417 lastName
= rec
->listLName
->data
;
422 fullName
= g_strdup_printf(
423 "%s %s", firstName
, lastName
);
426 fullName
= g_strdup_printf( "%s", firstName
);
431 fullName
= g_strdup_printf( "%s", lastName
);
435 if (!fullName
|| strlen(fullName
) == 0) {
439 fullName
= g_strdup(rec
->listCName
->data
);
443 g_strchug( fullName
); g_strchomp( fullName
);
446 if( rec
->listNName
) {
447 nickName
= rec
->listNName
->data
;
450 person
= addritem_create_item_person();
451 addritem_person_set_common_name( person
, fullName
);
452 addritem_person_set_first_name( person
, firstName
);
453 addritem_person_set_last_name( person
, lastName
);
454 addritem_person_set_nick_name( person
, nickName
);
455 addrcache_id_person( cache
, person
);
456 addrcache_add_person( cache
, person
);
457 ++ldifFile
->importCount
;
459 /* Add address item */
460 while( nodeAddress
) {
461 email
= addritem_create_item_email();
462 addritem_email_set_address( email
, nodeAddress
->data
);
463 addrcache_id_email( cache
, email
);
464 addrcache_person_add_email( cache
, person
, email
);
465 nodeAddress
= g_slist_next( nodeAddress
);
468 fullName
= firstName
= lastName
= NULL
;
470 /* Add user attributes */
471 nodeAttr
= rec
->userAttr
;
473 Ldif_UserAttr
*attr
= nodeAttr
->data
;
474 UserAttribute
*attrib
= addritem_create_attribute();
475 addritem_attrib_set_name( attrib
, attr
->name
);
476 addritem_attrib_set_value( attrib
, attr
->value
);
477 addritem_person_add_attribute( person
, attrib
);
478 nodeAttr
= g_slist_next( nodeAttr
);
484 * Add selected field as user attribute.
485 * \param rec LDIF field object.
486 * \param tagName LDIF tag name.
487 * \param tagValue Data value.
488 * \param hashField Hash table to populate.
490 static void ldif_add_user_attr(
491 Ldif_ParsedRec
*rec
, gchar
*tagName
, gchar
*tagValue
,
492 GHashTable
*hashField
)
494 Ldif_FieldRec
*fld
= NULL
;
495 Ldif_UserAttr
*attr
= NULL
;
498 fld
= g_hash_table_lookup( hashField
, tagName
);
500 if( ! fld
->selected
) return;
503 if( fld
->userName
) {
504 name
= fld
->userName
;
506 attr
= g_new0( Ldif_UserAttr
, 1 );
507 attr
->name
= g_strdup( name
);
508 attr
->value
= g_strdup( tagValue
);
509 rec
->userAttr
= g_slist_append( rec
->userAttr
, attr
);
514 * Add value to parsed data.
515 * \param rec LDIF field object.
516 * \param tagName LDIF tag name.
517 * \param tagValue Data value.
518 * \param hashField Hash table to populate.
520 static void ldif_add_value(
521 Ldif_ParsedRec
*rec
, gchar
*tagName
, gchar
*tagValue
,
522 GHashTable
*hashField
)
526 nm
= g_strdup( tagName
);
529 val
= g_strdup( tagValue
);
532 val
= g_strdup( "" );
536 if( g_utf8_collate( nm
, LDIF_TAG_COMMONNAME
) == 0 ) {
537 rec
->listCName
= g_slist_append( rec
->listCName
, val
);
539 else if( g_utf8_collate( nm
, LDIF_TAG_FIRSTNAME
) == 0 ) {
540 rec
->listFName
= g_slist_append( rec
->listFName
, val
);
542 else if( g_utf8_collate( nm
, LDIF_TAG_LASTNAME
) == 0 ) {
543 rec
->listLName
= g_slist_append( rec
->listLName
, val
);
545 else if( g_utf8_collate( nm
, LDIF_TAG_NICKNAME
) == 0 ) {
546 rec
->listNName
= g_slist_append( rec
->listNName
, val
);
548 else if( g_utf8_collate( nm
, LDIF_TAG_EMAIL
) == 0 ) {
549 rec
->listAddress
= g_slist_append( rec
->listAddress
, val
);
552 /* Add field as user attribute */
553 ldif_add_user_attr( rec
, tagName
, tagValue
, hashField
);
559 * Clear parsed data record.
560 * \param rec LDIF field object.
562 static void ldif_clear_rec( Ldif_ParsedRec
*rec
) {
565 /* Free up user attributes */
566 list
= rec
->userAttr
;
568 Ldif_UserAttr
*attr
= list
->data
;
569 g_free( attr
->name
);
570 g_free( attr
->value
);
572 list
= g_slist_next( list
);
574 g_slist_free( rec
->userAttr
);
576 g_slist_free( rec
->listCName
);
577 g_slist_free( rec
->listFName
);
578 g_slist_free( rec
->listLName
);
579 g_slist_free( rec
->listNName
);
580 g_slist_free( rec
->listAddress
);
581 g_slist_free( rec
->listID
);
583 rec
->userAttr
= NULL
;
584 rec
->listCName
= NULL
;
585 rec
->listFName
= NULL
;
586 rec
->listLName
= NULL
;
587 rec
->listNName
= NULL
;
588 rec
->listAddress
= NULL
;
593 * Read file data into address cache.
594 * Note that one LDIF record identifies one entity uniquely with the
595 * distinguished name (dn) tag. Each person can have multiple E-Mail
596 * addresses. Also, each person can have many common name (cn) tags.
598 * \param ldifFile LDIF import control object.
599 * \param cache Address cache to be populated with data.
601 static void ldif_read_file( LdifFile
*ldifFile
, AddressCache
*cache
) {
602 gchar
*tagName
= NULL
, *tagValue
= NULL
;
603 gchar
*lastTag
= NULL
, *fullValue
= NULL
;
604 GSList
*listValue
= NULL
;
605 gboolean flagEOF
= FALSE
, flagEOR
= FALSE
;
606 gboolean flag64
= FALSE
, last64
= FALSE
;
610 GHashTable
*hashField
;
612 hashField
= ldifFile
->hashFields
;
613 rec
= g_new0( Ldif_ParsedRec
, 1 );
614 ldif_clear_rec( rec
);
616 /* Find EOF for progress indicator */
617 fseek( ldifFile
->file
, 0L, SEEK_END
);
618 posEnd
= ftell( ldifFile
->file
);
619 fseek( ldifFile
->file
, 0L, SEEK_SET
);
622 gchar
*line
= ldif_get_line( ldifFile
);
624 posCur
= ftell( ldifFile
->file
);
625 if( ldifFile
->cbProgress
) {
626 /* Call progress indicator */
627 ( ldifFile
->cbProgress
) ( ldifFile
, & posEnd
, & posCur
);
632 flagEOF
= flagEOR
= TRUE
;
634 else if( *line
== '\0' ) {
639 /* EOR, Output address data */
642 fullValue
= mgu_list_coalesce( listValue
);
643 if (fullValue
&& last64
) {
644 gchar
*out
= g_malloc(strlen(fullValue
));
646 if ((len
= base64_decode(out
, fullValue
,
647 strlen(fullValue
))) >= 0) {
650 fullValue
[len
] = '\0';
654 /* Base-64 encoded data */
657 ldif_dump_b64( fullValue );
661 ldif_add_value( rec
, lastTag
, fullValue
, hashField
);
662 /* ldif_print_record( rec, stdout ); */
663 ldif_build_items( ldifFile
, rec
, cache
);
664 ldif_clear_rec( rec
);
666 mgu_free_list( listValue
);
675 /* Continuation line */
676 listValue
= g_slist_append(
677 listValue
, g_strdup( line
+1 ) );
679 else if( *line
== '=' ) {
680 /* Base-64 encoded continuation field */
681 listValue
= g_slist_append(
682 listValue
, g_strdup( line
) );
686 tagName
= ldif_get_tagname( line
, &flag64
);
688 tagValue
= ldif_get_tagvalue( line
);
693 mgu_list_coalesce( listValue
);
694 if (fullValue
&& last64
) {
695 gchar
*out
= g_malloc(strlen(fullValue
));
697 if ((len
= base64_decode(out
, fullValue
,
698 strlen(fullValue
))) >= 0) {
701 fullValue
[len
] = '\0';
705 /* Base-64 encoded data */
708 ldif_dump_b64( fullValue );
713 rec
, lastTag
, fullValue
,
716 mgu_free_list( listValue
);
722 lastTag
= g_strdup( tagName
);
723 listValue
= g_slist_append(
725 g_strdup( tagValue
) );
737 ldif_clear_rec( rec
);
740 mgu_free_list( listValue
);
744 * Add list of field names to hash table.
745 * \param table Hashtable.
746 * \param list List of fields.
748 static void ldif_hash_add_list( GHashTable
*table
, GSList
*list
) {
751 /* mgu_print_list( list, stdout ); */
753 gchar
*tag
= node
->data
;
754 if( ! g_hash_table_lookup( table
, tag
) ) {
755 Ldif_FieldRec
*rec
= NULL
;
756 gchar
*key
= g_strdup( tag
);
758 rec
= ldif_create_fieldrec( tag
);
759 if( g_utf8_collate( tag
, LDIF_TAG_DN
) == 0 ) {
760 rec
->reserved
= rec
->selected
= TRUE
;
761 rec
->userName
= g_strdup( "dn" );
763 else if( g_utf8_collate( tag
, LDIF_TAG_COMMONNAME
) == 0 ) {
764 rec
->reserved
= rec
->selected
= TRUE
;
765 rec
->userName
= g_strdup( _( "Display Name" ) );
767 else if( g_utf8_collate( tag
, LDIF_TAG_FIRSTNAME
) == 0 ) {
768 rec
->reserved
= rec
->selected
= TRUE
;
769 rec
->userName
= g_strdup( _( "First Name" ) );
771 else if( g_utf8_collate( tag
, LDIF_TAG_LASTNAME
) == 0 ) {
772 rec
->reserved
= rec
->selected
= TRUE
;
773 rec
->userName
= g_strdup( _( "Last Name" ) );
775 else if( g_utf8_collate( tag
, LDIF_TAG_NICKNAME
) == 0 ) {
776 rec
->reserved
= rec
->selected
= TRUE
;
777 rec
->userName
= g_strdup( _( "Nick Name" ) );
779 else if( g_utf8_collate( tag
, LDIF_TAG_EMAIL
) == 0 ) {
780 rec
->reserved
= rec
->selected
= TRUE
;
781 rec
->userName
= g_strdup( _( "Email Address" ) );
783 g_hash_table_insert( table
, key
, rec
);
785 node
= g_slist_next( node
);
790 * Sorted list comparison function.
791 * \param ptr1 First field.
792 * \param ptr2 Second field.
793 * \return <code>-1, 0, +1</code> if first record less than, equal,
794 * greater than second.
796 static gint
ldif_field_compare( gconstpointer ptr1
, gconstpointer ptr2
) {
797 const Ldif_FieldRec
*rec1
= ptr1
;
798 const Ldif_FieldRec
*rec2
= ptr2
;
800 if( rec1
->reserved
) {
801 if( ! rec2
->reserved
) {
806 if( rec2
->reserved
) {
810 return g_utf8_collate( rec1
->tagName
, rec2
->tagName
);
814 * Append hash table entry to list - visitor function.
816 * \param value Data value.
817 * \param data User data (the LDIF import control object).
819 static void ldif_hash2list_vis( gpointer key
, gpointer value
, gpointer data
) {
820 LdifFile
*ldf
= data
;
822 g_list_insert_sorted( ldf
->tempList
, value
, ldif_field_compare
);
826 * Read tag names for file data.
827 * \param ldifFile LDIF import control object.
829 static void ldif_read_tag_list( LdifFile
*ldifFile
) {
830 gchar
*tagName
= NULL
;
831 GSList
*listTags
= NULL
;
832 gboolean flagEOF
= FALSE
, flagEOR
= FALSE
, flagMail
= FALSE
;
833 gboolean flag64
= FALSE
;
837 /* Clear hash table */
838 g_hash_table_foreach_remove(
839 ldifFile
->hashFields
, ldif_hash_free_vis
, NULL
);
841 /* Find EOF for progress indicator */
842 fseek( ldifFile
->file
, 0L, SEEK_END
);
843 posEnd
= ftell( ldifFile
->file
);
844 fseek( ldifFile
->file
, 0L, SEEK_SET
);
847 ldifFile
->retVal
= MGU_EOF
;
853 gchar
*line
= ldif_get_line( ldifFile
);
854 posCur
= ftell( ldifFile
->file
);
855 if( ldifFile
->cbProgress
) {
856 /* Call progress indicator */
857 ( ldifFile
->cbProgress
) ( ldifFile
, & posEnd
, & posCur
);
862 flagEOF
= flagEOR
= TRUE
;
864 else if( *line
== '\0' ) {
869 /* EOR, Output address data */
870 /* Save field list to hash table */
873 ldifFile
->hashFields
, listTags
);
875 mgu_free_list( listTags
);
882 /* Continuation line */
884 else if( *line
== '=' ) {
885 /* Base-64 encoded continuation field */
889 tagName
= ldif_get_tagname( line
, &flag64
);
891 /* Add tag to list */
892 listTags
= g_slist_append( listTags
, tagName
);
895 tagName
, LDIF_TAG_EMAIL
) == 0 )
902 debug_print("ldif: bad format: '%s'\n", line
);
903 ldifFile
->retVal
= MGU_BAD_FORMAT
;
912 mgu_free_list( listTags
);
917 * Read file into list. Main entry point
918 * \param ldifFile LDIF import control object.
919 * \param cache Address cache to load.
920 * \return Status code.
922 gint
ldif_import_data( LdifFile
*ldifFile
, AddressCache
*cache
) {
923 g_return_val_if_fail( ldifFile
!= NULL
, MGU_BAD_ARGS
);
924 ldifFile
->retVal
= MGU_SUCCESS
;
925 addrcache_clear( cache
);
926 cache
->dataRead
= FALSE
;
927 ldif_open_file( ldifFile
);
928 if( ldifFile
->retVal
== MGU_SUCCESS
) {
929 /* Read data into the cache */
930 ldif_read_file( ldifFile
, cache
);
931 ldif_close_file( ldifFile
);
934 cache
->modified
= FALSE
;
935 cache
->dataRead
= TRUE
;
937 return ldifFile
->retVal
;
941 * Process entire file reading list of unique fields. List of fields may be
942 * accessed with the <code>ldif_get_fieldlist()</code> function.
943 * \param ldifFile LDIF import control object.
944 * \return Status code.
946 gint
ldif_read_tags( LdifFile
*ldifFile
) {
947 g_return_val_if_fail( ldifFile
!= NULL
, MGU_BAD_ARGS
);
948 ldifFile
->retVal
= MGU_SUCCESS
;
949 if( ldifFile
->dirtyFlag
) {
950 ldif_open_file( ldifFile
);
951 if( ldifFile
->retVal
== MGU_SUCCESS
) {
952 /* Read data into the cache */
953 ldif_read_tag_list( ldifFile
);
954 ldif_close_file( ldifFile
);
955 ldifFile
->dirtyFlag
= FALSE
;
956 ldifFile
->accessFlag
= TRUE
;
959 return ldifFile
->retVal
;
963 * Return list of fields for LDIF file.
964 * \param ldifFile LDIF import control object.
965 * \return Linked list of <code>Ldif_FieldRec</code> objects. This list may be
966 * <code>g_free()</code>. Note that the objects in the list should not
967 * be freed since they refer to objects inside the internal cache.
968 * These objects will be freed when LDIF file object is freed.
970 GList
*ldif_get_fieldlist( LdifFile
*ldifFile
) {
973 g_return_val_if_fail( ldifFile
!= NULL
, NULL
);
974 if( ldifFile
->hashFields
) {
975 ldifFile
->tempList
= NULL
;
976 g_hash_table_foreach( ldifFile
->hashFields
, ldif_hash2list_vis
, ldifFile
);
977 list
= ldifFile
->tempList
;
978 ldifFile
->tempList
= NULL
;
984 * Output LDIF name-value pair to stream. Only non-empty names and values will
986 * \param stream File output stream.
988 * \param value Data value.
989 * \return <i>TRUE</i> if data output.
991 gboolean
ldif_write_value( FILE *stream
, const gchar
*name
, const gchar
*value
) {
992 if( name
== NULL
) return FALSE
;
993 if( value
== NULL
) return FALSE
;
994 if( strlen( name
) < 1 ) return FALSE
;
995 if( strlen( value
) < 1 ) return FALSE
;
996 fprintf( stream
, "%s: ", name
);
997 fprintf( stream
, "%s\n", value
);
1002 * Output LDIF End of Record to stream.
1003 * \param stream File output stream.
1004 * \return <i>TRUE</i> if data output.
1006 void ldif_write_eor( FILE *stream
) {
1007 /* Simple but caller should not need to know how to end record. */
1008 fprintf( stream
, "\n" );
1012 * ============================================================================
1014 * ============================================================================