e2fb8fcb7c992f4d2959e92901a1bf77d579c391
[claws.git] / src / ldif.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2001 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 LDIF files (LDAP Data Interchange Format
22  * files).
23  */
24
25 #include <sys/stat.h>
26 #include <glib.h>
27
28 #include "mgutils.h"
29 #include "ldif.h"
30 #include "addritem.h"
31 #include "addrcache.h"
32
33 #include "base64.h"
34
35 /*
36 * Create new object.
37 */
38 LdifFile *ldif_create() {
39         LdifFile *ldifFile;
40         ldifFile = g_new0( LdifFile, 1 );
41         ldifFile->path = NULL;
42         ldifFile->file = NULL;
43         ldifFile->bufptr = ldifFile->buffer;
44         ldifFile->hashFields = g_hash_table_new( g_str_hash, g_str_equal );
45         ldifFile->tempList = NULL;
46         ldifFile->dirtyFlag = TRUE;
47         ldifFile->accessFlag = FALSE;
48         ldifFile->retVal = MGU_SUCCESS;
49         ldifFile->cbProgress = NULL;
50         ldifFile->importCount = 0;
51         return ldifFile;
52 }
53
54 /*
55 * Properties...
56 */
57 void ldif_set_file( LdifFile *ldifFile, const gchar *value ) {
58         g_return_if_fail( ldifFile != NULL );
59
60         if( ldifFile->path ) {
61                 if( strcmp( ldifFile->path, value ) != 0 )
62                         ldifFile->dirtyFlag = TRUE;
63         }
64         else {
65                 ldifFile->dirtyFlag = TRUE;
66         }
67         ldifFile->path = mgu_replace_string( ldifFile->path, value );
68         g_strstrip( ldifFile->path );
69         ldifFile->importCount = 0;
70 }
71 void ldif_set_accessed( LdifFile *ldifFile, const gboolean value ) {
72         g_return_if_fail( ldifFile != NULL );
73         ldifFile->accessFlag = value;
74 }
75
76 /*
77 * Register a callback function. When called, the function will be passed
78 * the following arguments:
79 *       LdifFile object,
80 *       File size (long),
81 *       Current position (long)
82 * This can be used for a progress indicator.
83 */
84 void ldif_set_callback( LdifFile *ldifFile, void *func ) {
85         ldifFile->cbProgress = func;
86 }
87
88 /*
89 * Create field record object.
90 */
91 static Ldif_FieldRec *ldif_create_fieldrec( gchar *field ) {
92         Ldif_FieldRec *rec = g_new0( Ldif_FieldRec, 1 );
93         rec->tagName = g_strdup( field );
94         rec->userName = NULL;
95         rec->reserved = FALSE;
96         rec->selected = FALSE;
97         return rec;
98 }
99
100 /*
101 * Free field record object.
102 */
103 static void ldif_free_fieldrec( Ldif_FieldRec *rec ) {
104         if( rec ) {
105                 g_free( rec->tagName );
106                 g_free( rec->userName );
107                 rec->tagName = NULL;
108                 rec->userName = NULL;
109                 rec->reserved = FALSE;
110                 rec->selected = FALSE;
111                 g_free( rec );
112         }
113 }
114
115 /*
116 * Free hash table entry visitor function.
117 */
118 static gint ldif_hash_free_vis( gpointer key, gpointer value, gpointer data ) {
119         ldif_free_fieldrec( ( Ldif_FieldRec * ) value );
120         value = NULL;
121         key = NULL;
122         return -1;
123 }
124
125 /*
126 * Free up object by releasing internal memory.
127 */
128 void ldif_free( LdifFile *ldifFile ) {
129         g_return_if_fail( ldifFile != NULL );
130
131         /* Close file */
132         if( ldifFile->file ) fclose( ldifFile->file );
133
134         /* Free internal stuff */
135         g_free( ldifFile->path );
136
137         /* Free field list */
138         g_hash_table_foreach_remove( ldifFile->hashFields, ldif_hash_free_vis, NULL );
139         g_hash_table_destroy( ldifFile->hashFields );
140         ldifFile->hashFields = NULL;
141
142         /* Clear pointers */
143         ldifFile->file = NULL;
144         ldifFile->path = NULL;
145         ldifFile->retVal = MGU_SUCCESS;
146         ldifFile->tempList = NULL;
147         ldifFile->dirtyFlag = FALSE;
148         ldifFile->accessFlag = FALSE;
149         ldifFile->cbProgress = NULL;
150
151         /* Now release file object */
152         g_free( ldifFile );
153 }
154
155 /*
156 * Display field record.
157 */
158 void ldif_print_fieldrec( Ldif_FieldRec *rec, FILE *stream ) {
159         fprintf( stream, "\ttag:\t%s", rec->reserved ? "yes" : "no" );
160         fprintf( stream, "\t%s", rec->selected ? "yes" : "no" );
161         fprintf( stream, "\t:%s:\t:%s:\n", rec->userName, rec->tagName );
162 }
163
164 /*
165 * Display field record.
166  * 
167 */
168 static void ldif_print_file_vis( gpointer key, gpointer value, gpointer data ) {
169         Ldif_FieldRec *rec = value;
170         FILE *stream = data;
171         ldif_print_fieldrec( rec, stream );
172 }
173
174 /*
175 * Display object to specified stream.
176 */
177 void ldif_print_file( LdifFile *ldifFile, FILE *stream ) {
178         g_return_if_fail( ldifFile != NULL );
179         fprintf( stream, "LDIF File:\n" );
180         fprintf( stream, "file spec: '%s'\n", ldifFile->path );
181         fprintf( stream, "  ret val: %d\n",   ldifFile->retVal );
182         fprintf( stream, "   fields: {\n" );
183         g_hash_table_foreach( ldifFile->hashFields, ldif_print_file_vis, stream );
184         fprintf( stream, "} ---\n" );
185 }
186
187 /*
188 * Open file for read.
189 * return: TRUE if file opened successfully.
190 */
191 static gint ldif_open_file( LdifFile* ldifFile ) {
192         /* printf( "Opening file\n" ); */
193         if( ldifFile->path ) {
194                 ldifFile->file = fopen( ldifFile->path, "r" );
195                 if( ! ldifFile->file ) {
196                         /* printf( "can't open %s\n", ldifFile->path ); */
197                         ldifFile->retVal = MGU_OPEN_FILE;
198                         return ldifFile->retVal;
199                 }
200         }
201         else {
202                 /* printf( "file not specified\n" ); */
203                 ldifFile->retVal = MGU_NO_FILE;
204                 return ldifFile->retVal;
205         }
206
207         /* Setup a buffer area */
208         ldifFile->buffer[0] = '\0';
209         ldifFile->bufptr = ldifFile->buffer;
210         ldifFile->retVal = MGU_SUCCESS;
211         return ldifFile->retVal;
212 }
213
214 /*
215 * Close file.
216 */
217 static void ldif_close_file( LdifFile *ldifFile ) {
218         g_return_if_fail( ldifFile != NULL );
219         if( ldifFile->file ) fclose( ldifFile->file );
220         ldifFile->file = NULL;
221 }
222
223 /*
224 * Read line of text from file.
225 * Return: ptr to buffer where line starts.
226 */
227 static gchar *ldif_get_line( LdifFile *ldifFile ) {
228         gchar buf[ LDIFBUFSIZE ];
229         gchar ch;
230         gchar *ptr;
231
232         if( feof( ldifFile->file ) ) return NULL;
233
234         ptr = buf;
235         while( TRUE ) {
236                 *ptr = '\0';
237                 ch = fgetc( ldifFile->file );
238                 if( ch == '\0' || ch == EOF ) {
239                         if( *buf == '\0' ) return NULL;
240                         break;
241                 }
242 #if HAVE_DOSISH_SYSTEM
243 #else
244                 if( ch == '\r' ) continue;
245 #endif
246                 if( ch == '\n' ) break;
247                 *ptr = ch;
248                 ptr++;
249         }
250
251         /* Return a copy of buffer */
252         return g_strdup( buf );
253 }
254
255 /*
256 * Parse tag name from line buffer.
257 * Enter: line   Buffer.
258 *        flag64 Base-64 encoder flag.
259 * Return: Buffer containing the tag name, or NULL if no delimiter char found.
260 * If a double delimiter (::) is found, flag64 is set.
261 */
262 static gchar *ldif_get_tagname( char* line, gboolean *flag64 ) {
263         gint len = 0;
264         gchar *tag = NULL;
265         gchar *lptr = line;
266         gchar *sptr = NULL;
267
268         while( *lptr++ ) {
269                 /* Check for language tag */
270                 if( *lptr == LDIF_LANG_TAG ) {
271                         if( sptr == NULL ) sptr = lptr;
272                 }
273
274                 /* Check for delimiter */
275                 if( *lptr == LDIF_SEP_TAG ) {
276                         if( sptr ) {
277                                 len = sptr - line;
278                         }
279                         else {
280                                 len = lptr - line;
281                         }
282
283                         /* Base-64 encoding? */
284                         if( * ++lptr == LDIF_SEP_TAG ) *flag64 = TRUE;
285
286                         tag = g_strndup( line, len+1 );
287                         tag[ len ] = '\0';
288                         g_strdown( tag );
289                         return tag;
290                 }
291         }
292         return tag;
293 }
294
295 /*
296 * Parse tag value from line buffer.
297 * Enter: line   Buffer.
298 * Return: Buffer containing the tag value. Empty string is returned if
299 * no delimiter char found.
300 */
301 static gchar *ldif_get_tagvalue( gchar* line ) {
302         gchar *value = NULL;
303         gchar *start = NULL;
304         gchar *lptr;
305         gint len = 0;
306
307         for( lptr = line; *lptr; lptr++ ) {
308                 if( *lptr == LDIF_SEP_TAG ) {
309                         if( ! start )
310                                 start = lptr + 1;
311                 }
312         }
313         if( start ) {
314                 if( *start == LDIF_SEP_TAG ) start++;
315                 len = lptr - start;
316                 value = g_strndup( start, len+1 );
317                 g_strstrip( value );
318         }
319         else {
320                 /* Ensure that we get an empty string */
321                 value = g_strndup( "", 1 );
322         }
323         value[ len ] = '\0';
324         return value;
325 }
326
327 /*
328 * Dump linked lists of character strings (for debug).
329 */
330 static void ldif_dump_lists( GSList *listName, GSList *listAddr, GSList *listRem, GSList *listID, FILE *stream ) {
331         fprintf( stream, "dump name\n" );
332         fprintf( stream, "------------\n" );
333         mgu_print_list( listName, stdout );
334         fprintf( stream, "dump address\n" );
335         fprintf( stream, "------------\n" );
336         mgu_print_list( listAddr, stdout );
337         fprintf( stream, "dump remarks\n" );
338         fprintf( stdout, "------------\n" );
339         mgu_print_list( listRem, stdout );
340         fprintf( stream, "dump id\n" );
341         fprintf( stdout, "------------\n" );
342         mgu_print_list( listID, stdout );
343 }
344
345 /*
346 * Parsed address data.
347 */
348 typedef struct _Ldif_ParsedRec_ Ldif_ParsedRec;
349 struct _Ldif_ParsedRec_ {
350         GSList *listCName;
351         GSList *listFName;
352         GSList *listLName;
353         GSList *listNName;
354         GSList *listAddress;
355         GSList *listID;
356         GSList *userAttr;
357 };
358
359 /*
360 * User attribute data.
361 */
362 typedef struct _Ldif_UserAttr_ Ldif_UserAttr;
363 struct _Ldif_UserAttr_ {
364         gchar *name;
365         gchar *value;
366 };
367
368 /*
369 * Build an address list entry and append to list of address items. Name is formatted
370 * as "<first-name> <last-name>".
371 */
372 static void ldif_build_items( LdifFile *ldifFile, Ldif_ParsedRec *rec, AddressCache *cache ) {
373         GSList *nodeFirst;
374         GSList *nodeAddress;
375         GSList *nodeAttr;
376         gchar *firstName = NULL, *lastName = NULL, *fullName = NULL, *nickName = NULL;
377         gint iLen = 0, iLenT = 0;
378         ItemPerson *person;
379         ItemEMail *email;
380
381         nodeAddress = rec->listAddress;
382         if( nodeAddress == NULL ) return;
383
384         /* Find longest first name in list */
385         nodeFirst = rec->listFName;
386         while( nodeFirst ) {
387                 if( firstName == NULL ) {
388                         firstName = nodeFirst->data;
389                         iLen = strlen( firstName );
390                 }
391                 else {
392                         if( ( iLenT = strlen( nodeFirst->data ) ) > iLen ) {
393                                 firstName = nodeFirst->data;
394                                 iLen = iLenT;
395                         }
396                 }
397                 nodeFirst = g_slist_next( nodeFirst );
398         }
399
400         /* Format name */
401         if( rec->listLName ) {
402                 lastName = rec->listLName->data;
403         }
404
405         if( firstName ) {
406                 if( lastName ) {
407                         fullName = g_strdup_printf( "%s %s", firstName, lastName );
408                 }
409                 else {
410                         fullName = g_strdup_printf( "%s", firstName );
411                 }
412         }
413         else {
414                 if( lastName ) {
415                         fullName = g_strdup_printf( "%s", lastName );
416                 }
417         }
418         if( fullName ) {
419                 g_strchug( fullName ); g_strchomp( fullName );
420         }
421
422         if( rec->listNName ) {
423                 nickName = rec->listNName->data;
424         }
425
426         person = addritem_create_item_person();
427         addritem_person_set_common_name( person, fullName );
428         addritem_person_set_first_name( person, firstName );
429         addritem_person_set_last_name( person, lastName );
430         addritem_person_set_nick_name( person, nickName );
431         addrcache_id_person( cache, person );
432         addrcache_add_person( cache, person );
433         ++ldifFile->importCount;
434
435         /* Add address item */
436         while( nodeAddress ) {
437                 email = addritem_create_item_email();
438                 addritem_email_set_address( email, nodeAddress->data );
439                 addrcache_id_email( cache, email );
440                 addrcache_person_add_email( cache, person, email );
441                 nodeAddress = g_slist_next( nodeAddress );
442         }
443         g_free( fullName );
444         fullName = firstName = lastName = NULL;
445
446         /* Add user attributes */
447         nodeAttr = rec->userAttr;
448         while( nodeAttr ) {
449                 Ldif_UserAttr *attr = nodeAttr->data;
450                 UserAttribute *attrib = addritem_create_attribute();
451                 addritem_attrib_set_name( attrib, attr->name );
452                 addritem_attrib_set_value( attrib, attr->value );
453                 addritem_person_add_attribute( person, attrib );
454                 nodeAttr = g_slist_next( nodeAttr );
455         }
456         nodeAttr = NULL;
457 }
458
459 /*
460 * Add selected field as user attribute.
461 */
462 static void ldif_add_user_attr( Ldif_ParsedRec *rec, gchar *tagName, gchar *tagValue, GHashTable *hashField ) {
463         Ldif_FieldRec *fld = NULL;
464         Ldif_UserAttr *attr = NULL;
465         gchar *name;
466
467         fld = g_hash_table_lookup( hashField, tagName );
468         if( fld ) {
469                 if( fld->reserved ) return;
470                 if( ! fld->selected ) return;
471
472                 name = fld->tagName;
473                 if( fld->userName ) {
474                         name = fld->userName;
475                 }
476                 attr = g_new0( Ldif_UserAttr, 1 );
477                 attr->name = g_strdup( name );
478                 attr->value = g_strdup( tagValue );
479                 rec->userAttr = g_slist_append( rec->userAttr, attr );
480         }
481 }
482
483 /*
484 * Add value to parsed data.
485 */
486 static void ldif_add_value( Ldif_ParsedRec *rec, gchar *tagName, gchar *tagValue, GHashTable *hashField ) {
487         gchar *nm, *val;
488
489         nm = g_strdup( tagName );
490         g_strdown( nm );
491         if( tagValue ) {
492                 val = g_strdup( tagValue );
493         }
494         else {
495                 val = g_strdup( "" );
496         }
497         g_strstrip( val );
498         if( g_strcasecmp( nm, LDIF_TAG_COMMONNAME ) == 0 ) {
499                 rec->listCName = g_slist_append( rec->listCName, val );
500         }
501         else if( g_strcasecmp( nm, LDIF_TAG_FIRSTNAME ) == 0 ) {
502                 rec->listFName = g_slist_append( rec->listFName, val );
503         }
504         else if( g_strcasecmp( nm, LDIF_TAG_LASTNAME ) == 0 ) {
505                 rec->listLName = g_slist_append( rec->listLName, val );
506         }
507         else if( g_strcasecmp( nm, LDIF_TAG_NICKNAME ) == 0 ) {
508                 rec->listNName = g_slist_append( rec->listNName, val );
509         }
510         else if( g_strcasecmp( nm, LDIF_TAG_EMAIL ) == 0 ) {
511                 rec->listAddress = g_slist_append( rec->listAddress, val );
512         }
513         else {
514                 /* Add field as user attribute */
515                 ldif_add_user_attr( rec, tagName, tagValue, hashField );
516         }
517         g_free( nm );
518 }
519
520 /*
521 * Clear parsed data.
522 */
523 static void ldif_clear_rec( Ldif_ParsedRec *rec ) {
524         GSList *list;
525
526         /* Free up user attributes */
527         list = rec->userAttr;
528         while( list ) {
529                 Ldif_UserAttr *attr = list->data;
530                 g_free( attr->name );
531                 g_free( attr->value );
532                 g_free( attr );
533                 list = g_slist_next( list );
534         }
535         g_slist_free( rec->userAttr );
536
537         g_slist_free( rec->listCName );
538         g_slist_free( rec->listFName );
539         g_slist_free( rec->listLName );
540         g_slist_free( rec->listNName );
541         g_slist_free( rec->listAddress );
542         g_slist_free( rec->listID );
543
544         rec->userAttr = NULL;
545         rec->listCName = NULL;
546         rec->listFName = NULL;
547         rec->listLName = NULL;
548         rec->listNName = NULL;
549         rec->listAddress = NULL;
550         rec->listID = NULL;
551 }
552
553 /*
554 * Print parsed data.
555 */
556 #if 0
557 static void ldif_print_record( Ldif_ParsedRec *rec, FILE *stream ) {
558         GSList *list;
559
560         fprintf( stream, "LDIF Parsed Record:\n" );
561         fprintf( stream, "common name:" );
562         mgu_print_list( rec->listCName, stream );
563         if( ! rec->listCName ) fprintf( stream, "\n" );
564         fprintf( stream, "first name:" );
565         mgu_print_list( rec->listFName, stream );
566         if( ! rec->listFName ) fprintf( stream, "\n" );
567         fprintf( stream, "last name:" );
568         mgu_print_list( rec->listLName, stream );
569         if( ! rec->listLName ) fprintf( stream, "\n" );
570         fprintf( stream, "nick name:" );
571         mgu_print_list( rec->listNName, stream );
572         if( ! rec->listNName ) fprintf( stream, "\n" );
573         fprintf( stream, "address:" );
574         mgu_print_list( rec->listAddress, stream );
575         if( ! rec->listAddress ) fprintf( stream, "\n" );
576         fprintf( stream, "id:" );
577         mgu_print_list( rec->listID, stream );
578         if( ! rec->listID ) fprintf( stream, "\n" );
579
580         list = rec->userAttr;
581         while( list ) {
582                 Ldif_UserAttr *attr = list->data;
583                 fprintf( stream, "n/v:\t%s:\t:%s:\n", attr->name, attr->value );
584                 list = g_slist_next( list );
585         }
586         list = NULL;
587 }
588 #endif
589
590 static void ldif_dump_b64( gchar *buf ) {
591         Base64Decoder *decoder = NULL;
592         gchar outBuf[8192];
593         gint len;
594
595         printf( "base-64 : inbuf : %s\n", buf );
596         decoder = base64_decoder_new();
597         len = base64_decoder_decode( decoder, buf, outBuf );
598         if (len < 0) {
599                 printf( "base-64 : Bad BASE64 content\n" );
600         }
601         else {
602                 outBuf[len] = '\0';
603                 printf( "base-64 : %d : %s\n\n", len, outBuf );
604         }
605         base64_decoder_free( decoder );
606         decoder = NULL;
607 }
608
609 /*
610 * Read file data into address cache.
611 * Note that one LDIF record identifies one entity uniquely with the
612 * distinguished name (dn) tag. Each person can have multiple E-Mail
613 * addresses. Also, each person can have many common name (cn) tags.
614 */
615 static void ldif_read_file( LdifFile *ldifFile, AddressCache *cache ) {
616         gchar *tagName = NULL, *tagValue = NULL;
617         gchar *lastTag = NULL, *fullValue = NULL;
618         GSList *listValue = NULL;
619         gboolean flagEOF = FALSE, flagEOR = FALSE;
620         gboolean flag64 = FALSE, last64 = FALSE;
621         Ldif_ParsedRec *rec;
622         long posEnd = 0L;
623         long posCur = 0L;
624         GHashTable *hashField;
625
626         hashField = ldifFile->hashFields;
627         rec = g_new0( Ldif_ParsedRec, 1 );
628         ldif_clear_rec( rec );
629
630         /* Find EOF for progress indicator */
631         fseek( ldifFile->file, 0L, SEEK_END );
632         posEnd = ftell( ldifFile->file );
633         fseek( ldifFile->file, 0L, SEEK_SET );
634
635         while( ! flagEOF ) {
636                 gchar *line =  ldif_get_line( ldifFile );
637
638                 posCur = ftell( ldifFile->file );
639                 if( ldifFile->cbProgress ) {
640                         /* Call progress indicator */
641                         ( ldifFile->cbProgress ) ( ldifFile, & posEnd, & posCur );
642                 }
643
644                 flag64 = FALSE;
645                 if( line == NULL ) {
646                         flagEOF = flagEOR = TRUE;
647                 }
648                 else if( *line == '\0' ) {
649                         flagEOR = TRUE;
650                 }
651
652                 if( flagEOR ) {
653                         /* EOR, Output address data */
654                         if( lastTag ) {
655                                 /* Save record */
656                                 fullValue = mgu_list_coalesce( listValue );
657
658                                 /* Base-64 encoded data */
659                                 /*
660                                 if( last64 ) {
661                                         ldif_dump_b64( fullValue );
662                                 }
663                                 */
664
665                                 ldif_add_value( rec, lastTag, fullValue, hashField );
666                                 /* ldif_print_record( rec, stdout ); */
667                                 ldif_build_items( ldifFile, rec, cache );
668                                 ldif_clear_rec( rec );
669                                 g_free( lastTag );
670                                 mgu_free_list( listValue );
671                                 lastTag = NULL;
672                                 listValue = NULL;
673                                 last64 = FALSE;
674                         }
675                 }
676                 if( line ) {
677                         flagEOR = FALSE;
678                         if( *line == ' ' ) {
679                                 /* Continuation line */
680                                 listValue = g_slist_append( listValue, g_strdup( line+1 ) );
681                         }
682                         else if( *line == '=' ) {
683                                 /* Base-64 encoded continuation field */
684                                 listValue = g_slist_append( listValue, g_strdup( line ) );
685                         }
686                         else {
687                                 /* Parse line */
688                                 tagName = ldif_get_tagname( line, &flag64 );
689                                 if( tagName ) {
690                                         tagValue = ldif_get_tagvalue( line );
691                                         if( tagValue ) {
692                                                 if( lastTag ) {
693                                                         /* Save data */
694                                                         fullValue = mgu_list_coalesce( listValue );
695                                                         /* Base-64 encoded data */
696                                                         /*
697                                                         if( last64 ) {
698                                                                 ldif_dump_b64( fullValue );
699                                                         }
700                                                         */
701
702                                                         ldif_add_value( rec, lastTag, fullValue, hashField );
703                                                         g_free( lastTag );
704                                                         mgu_free_list( listValue );
705                                                         lastTag = NULL;
706                                                         listValue = NULL;
707                                                         last64 = FALSE;
708                                                 }
709
710                                                 lastTag = g_strdup( tagName );
711                                                 listValue = g_slist_append( listValue, g_strdup( tagValue ) );
712                                                 g_free( tagValue );
713                                                 last64 = flag64;
714                                         }
715                                         g_free( tagName );
716                                 }
717                         }
718                 }
719                 g_free( line );
720         }
721
722         /* Release data */
723         ldif_clear_rec( rec );
724         g_free( rec );
725         g_free( lastTag );
726         mgu_free_list( listValue );
727 }
728
729 /*
730 * Add list of field names to hash table.
731 */
732 static void ldif_hash_add_list( GHashTable *table, GSList *list ) {
733         GSList *node = list;
734
735         /* mgu_print_list( list, stdout ); */
736         while( node ) {
737                 gchar *tag = node->data;
738                 if( ! g_hash_table_lookup( table, tag ) ) {
739                         Ldif_FieldRec *rec = NULL;
740                         gchar *key = g_strdup( tag );
741
742                         rec = ldif_create_fieldrec( tag );
743                         if( g_strcasecmp( tag, LDIF_TAG_COMMONNAME ) == 0 ) {
744                                 rec->reserved = TRUE;
745                         }
746                         else if( g_strcasecmp( tag, LDIF_TAG_FIRSTNAME ) == 0 ) {
747                                 rec->reserved = TRUE;
748                         }
749                         else if( g_strcasecmp( tag, LDIF_TAG_LASTNAME ) == 0 ) {
750                                 rec->reserved = TRUE;
751                         }
752                         else if( g_strcasecmp( tag, LDIF_TAG_NICKNAME ) == 0 ) {
753                                 rec->reserved = TRUE;
754                         }
755                         else if( g_strcasecmp( tag, LDIF_TAG_EMAIL ) == 0 ) {
756                                 rec->reserved = TRUE;
757                         }
758                         g_hash_table_insert( table, key, rec );
759                 }
760                 node = g_slist_next( node );
761         }
762 }
763
764 /*
765 * Sorted list comparison function.
766 */
767 static int ldif_field_compare( gconstpointer ptr1, gconstpointer ptr2 ) {
768         const Ldif_FieldRec *rec1 = ptr1;
769         const Ldif_FieldRec *rec2 = ptr2;
770         return g_strcasecmp( rec1->tagName, rec2->tagName );
771 }
772
773 /*
774 * Append hash table entry to list - visitor function.
775 */
776 static void ldif_hash2list_vis( gpointer key, gpointer value, gpointer data ) {
777         LdifFile *ldf = data;
778         ldf->tempList = g_list_insert_sorted( ldf->tempList, value, ldif_field_compare );
779 }
780
781 /*
782 * Read tag names for file data.
783 */
784 static void ldif_read_tag_list( LdifFile *ldifFile ) {
785         gchar *tagName = NULL;
786         GSList *listTags = NULL;
787         gboolean flagEOF = FALSE, flagEOR = FALSE, flagMail = FALSE;
788         gboolean flag64 = FALSE;
789         long posEnd = 0L;
790         long posCur = 0L;
791
792         /* Clear hash table */
793         g_hash_table_foreach_remove( ldifFile->hashFields, ldif_hash_free_vis, NULL );
794
795         /* Find EOF for progress indicator */
796         fseek( ldifFile->file, 0L, SEEK_END );
797         posEnd = ftell( ldifFile->file );
798         fseek( ldifFile->file, 0L, SEEK_SET );
799
800         /* Process file */
801         while( ! flagEOF ) {
802                 gchar *line = ldif_get_line( ldifFile );
803
804                 posCur = ftell( ldifFile->file );
805                 if( ldifFile->cbProgress ) {
806                         /* Call progress indicator */
807                         ( ldifFile->cbProgress ) ( ldifFile, & posEnd, & posCur );
808                 }
809
810                 flag64 = FALSE;
811                 if( line == NULL ) {
812                         flagEOF = flagEOR = TRUE;
813                 }
814                 else if( *line == '\0' ) {
815                         flagEOR = TRUE;
816                 }
817
818                 if( flagEOR ) {
819                         /* EOR, Output address data */
820                         /* Save field list to hash table */
821                         if( flagMail ) {
822                                 ldif_hash_add_list( ldifFile->hashFields, listTags );
823                         }
824                         mgu_free_list( listTags );
825                         listTags = NULL;
826                         flagMail = FALSE;
827                 }
828                 if( line ) {
829                         flagEOR = FALSE;
830                         if( *line == ' ' ) {
831                                 /* Continuation line */
832                         }
833                         else if( *line == '=' ) {
834                                 /* Base-64 encoded continuation field */
835                         }
836                         else {
837                                 /* Parse line */
838                                 tagName = ldif_get_tagname( line, &flag64 );
839                                 if( tagName ) {
840                                         /* Add tag to list */
841                                         listTags = g_slist_append( listTags, tagName );
842                                         if( g_strcasecmp( tagName, LDIF_TAG_EMAIL ) == 0 ) {
843                                                 flagMail = TRUE;
844                                         }
845                                 }
846                         }
847                 }
848                 g_free( line );
849         }
850
851         /* Release data */
852         mgu_free_list( listTags );
853         listTags = NULL;
854 }
855
856 /*
857 * ============================================================================
858 * Read file into list. Main entry point
859 * Enter:  ldifFile LDIF control data.
860 *         cache    Address cache to load.
861 * Return: Status code.
862 * ============================================================================
863 */
864 gint ldif_import_data( LdifFile *ldifFile, AddressCache *cache ) {
865         g_return_val_if_fail( ldifFile != NULL, MGU_BAD_ARGS );
866         ldifFile->retVal = MGU_SUCCESS;
867         addrcache_clear( cache );
868         cache->dataRead = FALSE;
869         ldif_open_file( ldifFile );
870         if( ldifFile->retVal == MGU_SUCCESS ) {
871                 /* Read data into the cache */
872                 ldif_read_file( ldifFile, cache );
873                 ldif_close_file( ldifFile );
874
875                 /* Mark cache */
876                 cache->modified = FALSE;
877                 cache->dataRead = TRUE;
878         }
879         return ldifFile->retVal;
880 }
881
882 /*
883 * ============================================================================
884 * Process entire file reading list of unique fields. List of fields may be
885 * accessed with the ldif_get_fieldlist() function.
886 * Enter:  ldifFile LDIF control data.
887 * Return: Status code.
888 * ============================================================================
889 */
890 gint ldif_read_tags( LdifFile *ldifFile ) {
891         g_return_val_if_fail( ldifFile != NULL, MGU_BAD_ARGS );
892         ldifFile->retVal = MGU_SUCCESS;
893         if( ldifFile->dirtyFlag ) {
894                 ldif_open_file( ldifFile );
895                 if( ldifFile->retVal == MGU_SUCCESS ) {
896                         /* Read data into the cache */
897                         ldif_read_tag_list( ldifFile );
898                         ldif_close_file( ldifFile );
899                         ldifFile->dirtyFlag = FALSE;
900                         ldifFile->accessFlag = TRUE;
901                 }
902         }
903         return ldifFile->retVal;
904 }
905
906 /*
907 * Return list of fields for LDIF file.
908 * Enter: ldifFile LdifFile object.
909 * Return: Linked list of Ldif_FieldRec objects. This list may be g_free'd.
910 * Note that the objects in the list should not be freed since they refer to
911 * objects inside the internal cache. These objects will be freed when
912 * LDIF file object is freed.
913 */
914 GList *ldif_get_fieldlist( LdifFile *ldifFile ) {
915         GList *list = NULL;
916
917         g_return_val_if_fail( ldifFile != NULL, NULL );
918         if( ldifFile->hashFields ) {
919                 ldifFile->tempList = NULL;
920                 g_hash_table_foreach( ldifFile->hashFields, ldif_hash2list_vis, ldifFile );
921                 list = ldifFile->tempList;
922                 ldifFile->tempList = NULL;
923         }
924         return list;
925 }
926
927 /*
928 * End of Source.
929 */
930