2004-11-12 [paul] 0.9.12cvs146.4
[claws.git] / src / exportldif.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2003 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  * Export address book to LDIF file.
22  */
23
24 #include <sys/stat.h>
25 #include <dirent.h>
26 #include <errno.h>
27 #include <time.h>
28 #include <string.h>
29 #include <glib.h>
30
31 #include "intl.h"
32 #include "mgutils.h"
33 #include "utils.h"
34 #include "exportldif.h"
35 #include "xmlprops.h"
36 #include "ldif.h"
37
38 #define DFL_DIR_SYLPHEED_OUT  "sylpheed-out"
39 #define DFL_FILE_SYLPHEED_OUT "addressbook.ldif"
40
41 #define FMT_BUFSIZE           2048
42 #define XML_BUFSIZE           2048
43
44 /* Settings - properties */
45 #define EXML_PROPFILE_NAME    "exportldif.xml"
46 #define EXMLPROP_DIRECTORY    "directory"
47 #define EXMLPROP_FILE         "file"
48 #define EXMLPROP_SUFFIX       "suffix"
49 #define EXMLPROP_RDN_INDEX    "rdn"
50 #define EXMLPROP_USE_DN       "use-dn"
51 #define EXMLPROP_EXCL_EMAIL   "exclude-mail"
52
53 static gchar *_attrName_UID_   = "uid";
54 static gchar *_attrName_DName_ = "cn";
55 static gchar *_attrName_EMail_ = "mail";
56
57 /**
58  * Create initialized LDIF export control object.
59  * \return Initialized export control data.
60  */
61 ExportLdifCtl *exportldif_create( void ) {
62         ExportLdifCtl *ctl = g_new0( ExportLdifCtl, 1 );
63
64         ctl->path = NULL;
65         ctl->dirOutput = NULL;
66         ctl->fileLdif = NULL;
67         ctl->suffix = NULL;
68         ctl->rdnIndex = EXPORT_LDIF_ID_UID;
69         ctl->useDN = FALSE;
70         ctl->excludeEMail = TRUE;
71         ctl->retVal = MGU_SUCCESS;
72         ctl->rcCreate = 0;
73         ctl->settingsFile = g_strconcat(
74                 get_rc_dir(), G_DIR_SEPARATOR_S, EXML_PROPFILE_NAME, NULL );
75
76         return ctl;
77 }
78
79 /**
80  * Free up object by releasing internal memory.
81  * \return ctl Export control data.
82  */
83 void exportldif_free( ExportLdifCtl *ctl ) {
84         g_return_if_fail( ctl != NULL );
85
86         g_free( ctl->path );
87         g_free( ctl->fileLdif );
88         g_free( ctl->dirOutput );
89         g_free( ctl->suffix );
90         g_free( ctl->settingsFile );
91
92         /* Clear pointers */
93         ctl->path = NULL;
94         ctl->dirOutput = NULL;
95         ctl->fileLdif = NULL;
96         ctl->suffix = NULL;
97         ctl->rdnIndex = EXPORT_LDIF_ID_UID;
98         ctl->useDN = FALSE;
99         ctl->excludeEMail = FALSE;
100         ctl->retVal = MGU_SUCCESS;
101         ctl->rcCreate = 0;
102
103         /* Now release object */
104         g_free( ctl );
105 }
106
107 /**
108  * Print control object.
109  * \param ctl    Export control data.
110  * \param stream Output stream.
111  */
112 void exportldif_print( ExportLdifCtl *ctl, FILE *stream ) {
113         fprintf( stream, "ExportLdifCtl:\n" );
114         fprintf( stream, "     path: %s\n", ctl->path );
115         fprintf( stream, "directory: %s\n", ctl->dirOutput );
116         fprintf( stream, "     file: %s\n", ctl->fileLdif );
117         fprintf( stream, "   suffix: %s\n", ctl->suffix );
118         fprintf( stream, "      rdn: %d\n", ctl->rdnIndex );
119         fprintf( stream, "   use DN: %s\n", ctl->useDN ? "y" : "n" );
120         fprintf( stream, " ex EMail: %s\n", ctl->excludeEMail ? "y" : "n" );
121         fprintf( stream, " settings: %s\n", ctl->settingsFile );
122 }
123
124 /**
125  * Specify directory where LDIF files are created.
126  * \param ctl   Export control data.
127  * \param value Full directory path.
128  */
129 void exportldif_set_output_dir( ExportLdifCtl *ctl, const gchar *value ) {
130         g_return_if_fail( ctl != NULL );
131         ctl->dirOutput = mgu_replace_string( ctl->dirOutput, value );
132         g_strstrip( ctl->dirOutput );
133 }
134
135 /**
136  * Specify full file specification of LDIF file.
137  * \param ctl   Export control data.
138  * \param value Full file specification.
139  */
140 void exportldif_set_path( ExportLdifCtl *ctl, const gchar *value ) {
141         g_return_if_fail( ctl != NULL );
142         ctl->path = mgu_replace_string( ctl->path, value );
143         g_strstrip( ctl->path );
144 }
145
146 /**
147  * Specify file name of LDIF file.
148  * \param ctl   Export control data.
149  * \param value File name.
150  */
151 void exportldif_set_file_ldif( ExportLdifCtl *ctl, const gchar *value ) {
152         g_return_if_fail( ctl != NULL );
153         ctl->fileLdif = mgu_replace_string( ctl->fileLdif, value );
154         g_strstrip( ctl->fileLdif );
155 }
156
157 /**
158  * Specify suffix to be used for creating DN entries.
159  * \param ctl   Export control data.
160  * \param value Suffix.
161  */
162 void exportldif_set_suffix( ExportLdifCtl *ctl, const char *value ) {
163         g_return_if_fail( ctl != NULL );
164         ctl->suffix = mgu_replace_string( ctl->suffix, value );
165         g_strstrip( ctl->suffix );
166 }
167
168 /**
169  * Specify index of variable to be used for creating RDN entries.
170  * \param ctl   Export control data.
171  * \param value Index to variable, as follows:
172  * <ul>
173  * <li><code>EXPORT_LDIF_ID_UID</code> - Use Sylpheed UID.</li>
174  * <li><code>EXPORT_LDIF_ID_DNAME</code> - Use Sylpheed display name.</li>
175  * <li><code>EXPORT_LDIF_ID_EMAIL</code> - Use first E-Mail address.</li>
176  * </ul>
177  */
178 void exportldif_set_rdn( ExportLdifCtl *ctl, const gint value ) {
179         g_return_if_fail( ctl != NULL );
180         ctl->rdnIndex = value;
181 }
182
183 /**
184  * Specify that <code>DN</code> attribute, if present, should be used as the
185  * DN for the entry.
186  * \param ctl   Export control data.
187  * \param value <i>TRUE</i> if DN should be used.
188  */
189 void exportldif_set_use_dn( ExportLdifCtl *ctl, const gboolean value ) {
190         g_return_if_fail( ctl != NULL );
191         ctl->useDN = value;
192 }
193
194 /**
195  * Specify that records without E-Mail addresses should be excluded.
196  * \param ctl   Export control data.
197  * \param value <i>TRUE</i> if records without E-Mail should be excluded.
198  */
199 void exportldif_set_exclude_email( ExportLdifCtl *ctl, const gboolean value ) {
200         g_return_if_fail( ctl != NULL );
201         ctl->excludeEMail = value;
202 }
203
204 /**
205  * Format LDAP value name with no embedded commas.
206  * \param  value Data value to format.
207  * \return Formatted string, should be freed after use.
208  */
209 static gchar *exportldif_fmt_value( gchar *value ) {
210         gchar *dupval;
211         gchar *src;
212         gchar *dest;
213         gchar ch;
214
215         /* Duplicate incoming value */
216         dest = dupval = g_strdup( value );
217
218         /* Copy characters, ignoring commas */
219         src = value;
220         while( *src ) {
221                 ch = *src;
222                 if( ch != ',' ) {
223                         *dest = ch;
224                         dest++;
225                 }
226                 src++;
227         }
228         *dest = '\0';
229         return dupval;
230 }
231
232 /**
233  * Build DN for entry.
234  * \param  ctl    Export control data.
235  * \param  person Person to format.
236  * \return Formatted DN entry.
237  */
238 static gchar *exportldif_fmt_dn(
239                 ExportLdifCtl *ctl, const ItemPerson *person )
240 {
241         gchar buf[ FMT_BUFSIZE ];
242         gchar *retVal = NULL;
243         gchar *attr = NULL;
244         gchar *value = NULL;
245         gchar *dupval = NULL;
246
247         /* Process RDN */
248         *buf = '\0';
249         if( ctl->rdnIndex == EXPORT_LDIF_ID_UID ) {
250                 attr = _attrName_UID_;
251                 value = ADDRITEM_ID( person );
252         }
253         else if( ctl->rdnIndex == EXPORT_LDIF_ID_DNAME ) {
254                 attr = _attrName_DName_;
255                 value = ADDRITEM_NAME( person );
256                 dupval = exportldif_fmt_value( value );
257         }
258         else if( ctl->rdnIndex == EXPORT_LDIF_ID_EMAIL ) {
259                 GList *node;
260
261                 node = person->listEMail;
262                 if( node ) {
263                         ItemEMail *email = node->data;
264
265                         attr = _attrName_EMail_;
266                         value = email->address;
267                         dupval = exportldif_fmt_value( value );
268                 }
269         }
270
271         /* Format DN */
272         if( attr ) {
273                 if( value ) {
274                         if( strlen( value ) > 0 ) {
275                                 strcat( buf, attr );
276                                 strcat( buf, "=" );
277                                 if( dupval ) {
278                                         /* Format and free duplicated value */
279                                         strcat( buf, dupval );
280                                         g_free( dupval );
281                                 }
282                                 else {
283                                         /* Use original value */
284                                         strcat( buf, value );
285                                 }
286
287                                 /* Append suffix */
288                                 if( ctl->suffix ) {
289                                         if( strlen( ctl->suffix ) > 0 ) {
290                                                 strcat( buf, "," );
291                                                 strcat( buf, ctl->suffix );
292                                         }
293                                 }
294
295                                 retVal = g_strdup( buf );
296                         }
297                 }
298         }
299         return retVal;
300 }
301
302 /**
303  * Find DN by searching attribute list.
304  * \param  ctl    Export control data.
305  * \param  person Person to format.
306  * \return Formatted DN entry, should be freed after use.
307  */
308 static gchar *exportldif_find_dn(
309                         ExportLdifCtl *ctl, const ItemPerson *person )
310 {
311         gchar *retVal = NULL;
312         const GList *node;
313
314         node = person->listAttrib;
315         while( node ) {
316                 UserAttribute *attrib = node->data;
317
318                 node = g_list_next( node );
319                 if( g_utf8_collate( attrib->name, LDIF_TAG_DN ) == 0 ) {
320                         retVal = g_strdup( attrib->value );
321                         break;
322                 }
323         }
324         return retVal;
325 }
326
327 /**
328  * Format E-Mail entries for person.
329  * \param  person Person to format.
330  * \param  stream Output stream.
331  * \return <i>TRUE</i> if entry formatted.
332  */
333 static gboolean exportldif_fmt_email( const ItemPerson *person, FILE *stream ) {
334         gboolean retVal = FALSE;
335         const GList *node;
336
337         node = person->listEMail;
338         while( node ) {
339                 ItemEMail *email = node->data;
340
341                 node = g_list_next( node );
342                 ldif_write_value( stream, LDIF_TAG_EMAIL, email->address );
343                 retVal = TRUE;
344         }
345         return retVal;
346 }
347
348 /**
349  * Test for E-Mail entries for person.
350  * \param  person Person to test.
351  * \return <i>TRUE</i> if person has E-Mail address.
352  */
353 static gboolean exportldif_test_email( const ItemPerson *person )
354 {
355         gboolean retVal = FALSE;
356         const GList *node;
357
358         node = person->listEMail;
359         while( node ) {
360                 ItemEMail *email = node->data;
361
362                 node = g_list_next( node );
363                 if( email->address ) {
364                         if( strlen( email->address ) > 0 ) {
365                                 retVal = TRUE;
366                                 break;
367                         }
368                 }
369                 retVal = TRUE;
370         }
371         return retVal;
372 }
373
374 /**
375  * Format persons in an address book folder.
376  * \param  ctl    Export control data.
377  * \param  stream Output stream.
378  * \param  folder Folder to format.
379  * \return <i>TRUE</i> if no persons were formatted.
380  */
381 static gboolean exportldif_fmt_person(
382                 ExportLdifCtl *ctl, FILE *stream, const ItemFolder *folder )
383 {
384         gboolean retVal = TRUE;
385         const GList *node;
386
387         if( folder->listPerson == NULL ) return retVal;
388
389         node = folder->listPerson;
390         while( node ) {
391                 AddrItemObject *aio = node->data;
392                 node = g_list_next( node );
393
394                 if( aio && aio->type == ITEMTYPE_PERSON ) {
395                         ItemPerson *person = ( ItemPerson * ) aio;
396                         gboolean classPerson = FALSE;
397                         gboolean classInetP = FALSE;
398                         gchar *dn = NULL;
399
400                         /* Check for E-Mail */
401                         if( exportldif_test_email( person ) ) {
402                                 classInetP = TRUE;
403                         }
404                         else {
405                                 /* Bail if no E-Mail address */
406                                 if( ctl->excludeEMail ) continue;
407                         }
408
409                         /* Format DN */
410                         if( ctl->useDN ) {
411                                 dn = exportldif_find_dn( ctl, person );
412                         }
413                         if( dn == NULL ) {
414                                 dn = exportldif_fmt_dn( ctl, person );
415                         }
416                         if( dn == NULL ) continue;
417                         ldif_write_value( stream, LDIF_TAG_DN, dn );
418                         g_free( dn );
419
420                         /*
421                          * Test for schema requirements. This is a simple
422                          * test and does not trap all LDAP schema errors.
423                          * These can be detected when the LDIF file is
424                          * loaded into an LDAP server.
425                          */
426                         if( person->lastName ) {
427                                 if( strlen( person->lastName ) > 0 ) {
428                                         classPerson = TRUE;
429                                         classInetP = TRUE;
430                                 }
431                         }
432
433                         if( classPerson ) {
434                                 ldif_write_value( stream,
435                                         LDIF_TAG_OBJECTCLASS, LDIF_CLASS_PERSON );
436                         }
437                         if( classInetP ) {
438                                 ldif_write_value( stream,
439                                         LDIF_TAG_OBJECTCLASS, LDIF_CLASS_INET_PERSON );
440                         }
441
442                         /* Format person attributes */
443                         ldif_write_value(
444                                 stream, LDIF_TAG_COMMONNAME, ADDRITEM_NAME( person ) );
445                         ldif_write_value(
446                                 stream, LDIF_TAG_LASTNAME, person->lastName );
447                         ldif_write_value(
448                                 stream, LDIF_TAG_FIRSTNAME, person->firstName );
449                         ldif_write_value(
450                                 stream, LDIF_TAG_NICKNAME, person->nickName );
451
452                         /* Format E-Mail */
453                         exportldif_fmt_email( person, stream );
454
455                         /* End record */
456                         ldif_write_eor( stream );
457
458                         retVal = FALSE;
459                 }
460         }
461
462         return retVal;
463 }
464
465 /**
466  * Format an address book folder.
467  * \param  ctl    Export control data.
468  * \param  stream Output stream.
469  * \param  folder Folder to format.
470  * \return <i>TRUE</i> if no persons were formatted.
471  */
472 static void exportldif_fmt_folder(
473                 ExportLdifCtl *ctl, FILE *stream, const ItemFolder *folder )
474 {
475         const GList *node;
476
477         /* Export entries in this folder */
478         exportldif_fmt_person( ctl, stream, folder );
479
480         /* Export entries in sub-folders */
481         node = folder->listFolder;
482         while( node ) {
483                 AddrItemObject *aio = node->data;
484
485                 node = g_list_next( node );
486                 if( aio && aio->type == ITEMTYPE_FOLDER ) {
487                         ItemFolder *subFolder = ( ItemFolder * ) aio;
488                         exportldif_fmt_folder( ctl, stream, subFolder );
489                 }
490         }
491 }
492
493 /**
494  * Export address book to LDIF file.
495  * \param  ctl   Export control data.
496  * \param  cache Address book/data source cache.
497  * \return Status.
498  */
499 void exportldif_process( ExportLdifCtl *ctl, AddressCache *cache )
500 {
501         ItemFolder *rootFolder;
502         FILE *ldifFile;
503
504         ldifFile = fopen( ctl->path, "wb" );
505         if( ! ldifFile ) {
506                 /* Cannot open file */
507                 ctl->retVal = MGU_OPEN_FILE;
508                 return;
509         }
510
511         rootFolder = cache->rootFolder;
512         exportldif_fmt_folder( ctl, ldifFile, rootFolder );
513         fclose( ldifFile );
514         ctl->retVal = MGU_SUCCESS;
515 }
516
517 /**
518  * Build full export file specification.
519  * \param ctl  Export control data.
520  */
521 static void exportldif_build_filespec( ExportLdifCtl *ctl ) {
522         gchar *fileSpec;
523
524         fileSpec = g_strconcat(
525                 ctl->dirOutput, G_DIR_SEPARATOR_S, ctl->fileLdif, NULL );
526         ctl->path = mgu_replace_string( ctl->path, fileSpec );
527         g_free( fileSpec );
528 }
529
530 /**
531  * Parse directory and filename from full export file specification.
532  * \param ctl      Export control data.
533  * \param fileSpec File spec.
534  */
535 void exportldif_parse_filespec( ExportLdifCtl *ctl, gchar *fileSpec ) {
536         gchar *t;
537
538         ctl->fileLdif =
539                 mgu_replace_string( ctl->fileLdif, g_basename( fileSpec ) );
540         t = g_path_get_dirname( fileSpec );
541         ctl->dirOutput = mgu_replace_string( ctl->dirOutput, t );
542         g_free( t );
543         ctl->path = mgu_replace_string( ctl->path, fileSpec );
544 }
545
546 /**
547  * Test whether output directory exists.
548  * \param  ctl Export control data.
549  * \return TRUE if exists.
550  */
551 gboolean exportldif_test_dir( ExportLdifCtl *ctl ) {
552         gboolean retVal;
553         DIR *dp;
554
555         retVal = FALSE;
556         if((dp = opendir( ctl->dirOutput )) != NULL) {
557                 retVal = TRUE;
558                 closedir( dp );
559         }
560         return retVal;
561 }
562
563 /**
564  * Create output directory.
565  * \param  ctl Export control data.
566  * \return TRUE if directory created.
567  */
568 gboolean exportldif_create_dir( ExportLdifCtl *ctl ) {
569         gboolean retVal = FALSE;
570
571         ctl->rcCreate = 0;
572         if( mkdir( ctl->dirOutput, S_IRWXU ) == 0 ) {
573                 retVal = TRUE;
574         }
575         else {
576                 ctl->rcCreate = errno;
577         }
578         return retVal;
579 }
580
581 /**
582  * Retrieve create directory error message.
583  * \param  ctl Export control data.
584  * \return Message.
585  */
586 gchar *exportldif_get_create_msg( ExportLdifCtl *ctl ) {
587         gchar *msg;
588
589         if( ctl->rcCreate == EEXIST ) {
590                 msg = _( "Name already exists but is not a directory." );
591         }
592         else if( ctl->rcCreate == EACCES ) {
593                 msg = _( "No permissions to create directory." );
594         }
595         else if( ctl->rcCreate == ENAMETOOLONG ) {
596                 msg = _( "Name is too long." );
597         }
598         else {
599                 msg = _( "Not specified." );
600         }
601         return msg;
602 }
603
604 /**
605  * Set default values.
606  * \param  ctl Export control data.
607  */
608 static void exportldif_default_values( ExportLdifCtl *ctl ) {
609         gchar *str;
610
611         str = g_strconcat(
612                 g_get_home_dir(), G_DIR_SEPARATOR_S,
613                 DFL_DIR_SYLPHEED_OUT, NULL );
614
615         ctl->dirOutput = mgu_replace_string( ctl->dirOutput, str );
616         g_free( str );
617
618         ctl->fileLdif =
619                 mgu_replace_string( ctl->fileLdif, DFL_FILE_SYLPHEED_OUT );
620         ctl->suffix = mgu_replace_string( ctl->suffix, "" );
621
622         ctl->rdnIndex = EXPORT_LDIF_ID_UID;
623         ctl->useDN = FALSE;
624         ctl->retVal = MGU_SUCCESS;
625 }
626
627 /**
628  * Load settings from XML properties file.
629  * \param  ctl Export control data.
630  */
631 void exportldif_load_settings( ExportLdifCtl *ctl ) {
632         XmlProperty *props;
633         gint rc;
634         gchar buf[ XML_BUFSIZE ];
635
636         props = xmlprops_create();
637         xmlprops_set_path( props, ctl->settingsFile );
638         rc = xmlprops_load_file( props );
639         if( rc == 0 ) {
640                 /* Read settings */
641                 *buf = '\0';
642                 xmlprops_get_property_s( props, EXMLPROP_DIRECTORY, buf );
643                 ctl->dirOutput = mgu_replace_string( ctl->dirOutput, buf );
644
645                 *buf = '\0';
646                 xmlprops_get_property_s( props, EXMLPROP_FILE, buf );
647                 ctl->fileLdif = mgu_replace_string( ctl->fileLdif, buf );
648
649                 *buf = '\0';
650                 xmlprops_get_property_s( props, EXMLPROP_SUFFIX, buf );
651                 ctl->suffix = mgu_replace_string( ctl->suffix, buf );
652
653                 ctl->rdnIndex =
654                         xmlprops_get_property_i( props, EXMLPROP_RDN_INDEX );
655                 ctl->useDN =
656                         xmlprops_get_property_b( props, EXMLPROP_USE_DN );
657                 ctl->excludeEMail =
658                         xmlprops_get_property_b( props, EXMLPROP_EXCL_EMAIL );
659         }
660         else {
661                 /* Set default values */
662                 exportldif_default_values( ctl );
663         }
664         exportldif_build_filespec( ctl );
665         /* exportldif_print( ctl, stdout ); */
666
667         xmlprops_free( props );
668 }
669
670 /**
671  * Save settings to XML properties file.
672  * \param  ctl Export control data.
673  */
674 void exportldif_save_settings( ExportLdifCtl *ctl ) {
675         XmlProperty *props;
676
677         props = xmlprops_create();
678         xmlprops_set_path( props, ctl->settingsFile );
679
680         xmlprops_set_property( props, EXMLPROP_DIRECTORY, ctl->dirOutput );
681         xmlprops_set_property( props, EXMLPROP_FILE, ctl->fileLdif );
682         xmlprops_set_property( props, EXMLPROP_SUFFIX, ctl->suffix );
683         xmlprops_set_property_i( props, EXMLPROP_RDN_INDEX, ctl->rdnIndex );
684         xmlprops_set_property_b( props, EXMLPROP_USE_DN, ctl->useDN );
685         xmlprops_set_property_b( props, EXMLPROP_EXCL_EMAIL, ctl->excludeEMail );
686         xmlprops_save_file( props );
687         xmlprops_free( props );
688 }
689
690 /*
691  * ============================================================================
692  * End of Source.
693  * ============================================================================
694  */
695
696