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