X-Git-Url: https://git.deb.at/w?p=pkg%2Fabook.git;a=blobdiff_plain;f=filter.c;h=a22a0c766ad7c26853b9aae48d9cdd9b11722685;hp=1f171722673733c6d5f17a7fcd3cab494d113c44;hb=db05da322d7ef6bd94e097fb95af1ffead328b96;hpb=7d7ae6aab5fb6307328b7cfb193ebce3e2870624

diff --git a/filter.c b/filter.c
index 1f17172..a22a0c7 100644
--- a/filter.c
+++ b/filter.c
@@ -7,6 +7,8 @@
  * Copyright (C) Jaakko Heinonen
  */
 
+#define _GNU_SOURCE
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -27,6 +29,10 @@
 #include "xmalloc.h"
 #include <assert.h>
 
+#ifdef HAVE_VFORMAT
+#include "vcard.h"
+#endif
+
 extern abook_field_list *fields_list;
 extern int fields_count;
 
@@ -44,6 +50,7 @@ static int	pine_parse_file(FILE *in);
 static int 	csv_parse_file(FILE *in);
 static int 	allcsv_parse_file(FILE *in);
 static int 	palmcsv_parse_file(FILE *in);
+static int 	vcard_parse_file(FILE *in);
 
 /*
  * export filter prototypes
@@ -55,12 +62,23 @@ static int	pine_export_database(FILE *out, struct db_enumerator e);
 static int	csv_export_database(FILE *out, struct db_enumerator e);
 static int	allcsv_export_database(FILE *out, struct db_enumerator e);
 static int	palm_export_database(FILE *out, struct db_enumerator e);
-static int	gcrd_export_database(FILE *out, struct db_enumerator e);
+static int	vcard_export_database(FILE *out, struct db_enumerator e);
 static int	mutt_alias_export(FILE *out, struct db_enumerator e);
+static int	mutt_query_export_database(FILE *out, struct db_enumerator e);
 static int	elm_alias_export(FILE *out, struct db_enumerator e);
 static int	text_export_database(FILE *out, struct db_enumerator e);
 static int	spruce_export_database(FILE *out, struct db_enumerator e);
 static int	wl_export_database(FILE *out, struct db_enumerator e);
+static int	bsdcal_export_database(FILE *out, struct db_enumerator e);
+static int	custom_export_database(FILE *out, struct db_enumerator e);
+
+/*
+ * export filter item prototypes
+ */
+
+void vcard_export_item(FILE *out, int item);
+void muttq_print_item(FILE *file, int item);
+void custom_print_item(FILE *out, int item);
 
 /*
  * end of function declarations
@@ -74,16 +92,18 @@ struct abook_input_filter i_filters[] = {
 	{ "csv", N_("comma separated values"), csv_parse_file },
 	{ "allcsv", N_("comma separated values (all fields)"), allcsv_parse_file },
 	{ "palmcsv", N_("Palm comma separated values"), palmcsv_parse_file },
+	{ "vcard", N_("vCard file"), vcard_parse_file },
 	{ "\0", NULL, NULL }
 };
 
 struct abook_output_filter e_filters[] = {
 	{ "abook", N_("abook native format"), write_database },
 	{ "ldif", N_("ldif / Netscape addressbook (.4ld)"), ldif_export_database },
+	{ "vcard", N_("vCard 2 file"), vcard_export_database },
 	{ "mutt", N_("mutt alias"), mutt_alias_export },
+	{ "muttq", N_("mutt query format (internal use)"), mutt_query_export_database },
 	{ "html", N_("html document"), html_export_database },
 	{ "pine", N_("pine addressbook"), pine_export_database },
-	{ "gcrd", N_("GnomeCard (VCard) addressbook"), gcrd_export_database },
 	{ "csv", N_("comma separated values"), csv_export_database },
 	{ "allcsv", N_("comma separated values (all fields)"), allcsv_export_database },
 	{ "palmcsv", N_("Palm comma separated values"), palm_export_database},
@@ -91,9 +111,18 @@ struct abook_output_filter e_filters[] = {
 	{ "text", N_("plain text"), text_export_database },
 	{ "wl", N_("Wanderlust address book"), wl_export_database },
 	{ "spruce", N_("Spruce address book"), spruce_export_database },
+	{ "bsdcal", N_("BSD calendar"), bsdcal_export_database },
+	{ "custom", N_("Custom format"), custom_export_database },
 	{ "\0", NULL, NULL }
 };
 
+struct abook_output_item_filter u_filters[] = {
+	{ "vcard", N_("vCard 2 file"), vcard_export_item },
+	{ "muttq", N_("mutt alias"), muttq_print_item },
+	{ "custom", N_("Custom format"), custom_print_item },
+	{ "\0", NULL }
+};
+
 /*
  * common functions
  */
@@ -103,19 +132,26 @@ print_filters()
 {
 	int i;
 
-	puts(_("input:"));
+	puts(_("input formats:"));
 	for(i=0; *i_filters[i].filtname ; i++)
 		printf("\t%s\t%s\n", i_filters[i].filtname,
 			gettext(i_filters[i].desc));
 
 	putchar('\n');
 
-	puts(_("output:"));
+	puts(_("output formats:"));
 	for(i=0; *e_filters[i].filtname ; i++)
 		printf("\t%s\t%s\n", e_filters[i].filtname,
 			gettext(e_filters[i].desc));
 
 	putchar('\n');
+
+	puts(_("query-compatible output formats:"));
+	for(i=0; *u_filters[i].filtname ; i++)
+		printf("\t%s\t%s\n", u_filters[i].filtname,
+			gettext(u_filters[i].desc));
+
+	putchar('\n');
 }
 
 static int
@@ -261,6 +297,18 @@ import_file(char filtname[FILTNAME_LEN], char *filename)
 	if(i < 0)
 		return -1;
 
+#ifdef HAVE_VFORMAT
+	// this is a special case for
+	// libvformat whose API expects a filename
+	if(!strcmp(filtname, "vcard")) {
+	  if(!strcmp(filename, "-"))
+	    ret = vcard_parse_file_libvformat("/dev/stdin");
+	  else
+	    ret = vcard_parse_file_libvformat(filename);
+	}
+	else
+#endif
+
 	if(!strcmp(filename, "-")) {
 		struct stat s;
 		if((fstat(fileno(stdin), &s)) == -1 || S_ISDIR(s.st_mode))
@@ -355,6 +403,25 @@ export_database()
 	return 0;
 }
 
+struct abook_output_item_filter select_output_item_filter(char filtname[FILTNAME_LEN]) {
+	int i;
+	for(i=0;; i++) {
+		if(!strncasecmp(u_filters[i].filtname, filtname, FILTNAME_LEN))
+		  break;
+		if(!*u_filters[i].filtname) {
+		  i = -1;
+		  break;
+		}
+	}
+	return u_filters[i];
+}
+
+void
+e_write_item(FILE *out, int item, void (*func) (FILE *in, int item))
+{
+  (*func) (out, item);
+}
+
 static int
 e_write_file(char *filename, int (*func) (FILE *in, struct db_enumerator e),
 		int mode)
@@ -436,79 +503,151 @@ export_file(char filtname[FILTNAME_LEN], char *filename)
 
 #include "ldif.h"
 
-static void	ldif_fix_string(char *str);
+/* During LDIF import we need more fields than the
+   ITEM_FIELDS of a *list_item. Eg: "objectclass"
+   to test valid records, ...
+   Here we extends the existing field_types enum
+   to define new fields indexes usable during processing.
+   Newly created LDIF attr names could be associated to
+   them using ldif_conv_table[]. */
+typedef enum {
+	LDIF_OBJECTCLASS = ITEM_FIELDS + 1
+} ldif_field_types;
 
-#define	LDIF_ITEM_FIELDS	16
+#define	LDIF_ITEM_FIELDS	LDIF_OBJECTCLASS
 
 typedef char *ldif_item[LDIF_ITEM_FIELDS];
 
+/* LDIF field's names *must* respect the ordering
+   defined by the field_types enum from database.h
+   This is only used to define (for export only)
+   abook standard field to LDIF attr name mappings */
 static ldif_item ldif_field_names = {
-	"cn",
-	"mail",
-	"streetaddress",
-	"streetaddress2",
-        "locality",
-	"st",
-	"postalcode",
-	"countryname",
-	"homephone",
-	"description",
-	"homeurl",
-	"facsimiletelephonenumber",
-	"cellphone",
-	"xmozillaanyphone",
-	"xmozillanickname",
-	"objectclass", /* this must be the last entry */
+	"cn",			// NAME
+	"mail",			// EMAIL
+	"streetaddress",	// ADDRESS
+	"streetaddress2",	// ADDRESS2
+	"locality",		// CITY
+	"st",			// STATE
+	"postalcode",		// ZIP
+	"countryname",		// COUNTRY
+	"homephone",		// PHONE
+	"telephonenumber",	// WORKPHONE
+	"facsimiletelephonenumber",	// FAX
+	"cellphone",		// MOBILEPHONE
+	"xmozillanickname",	// NICK
+	"homeurl",		// URL
+	"description",		// NOTES
+	"anniversary",		// ANNIVERSARY
+	"ou",			// GROUPS
 };
 
-static int ldif_conv_table[LDIF_ITEM_FIELDS] = {
-	NAME,		/* "cn" */
-	EMAIL,		/* "mail" */
-	ADDRESS,	/* "streetaddress" */
-	ADDRESS2,	/* "streetaddress2" */
-        CITY,		/* "locality" */
-	STATE,		/* "st" */
-	ZIP,		/* "postalcode" */
-	COUNTRY,	/* "countryname" */
-	PHONE,		/* "homephone" */
-	NOTES,		/* "description" */
-	URL,		/* "homeurl" */
-	FAX,		/* "facsimiletelephonenumber" */
-	MOBILEPHONE,	/* "cellphone" */
-	WORKPHONE,	/* "xmozillaanyphone" */
-	NICK,		/* "xmozillanickname" */
-	-1,             /* "objectclass" */ /* this must be the last entry */
+/* Used to map LDIF attr names from input to
+   the abook restricted set of standard fields. */
+typedef struct {
+	char *key;
+	int  index;
+} ldif_available_items;
+
+static ldif_available_items ldif_conv_table[] = {
+	/* initial field names respect the field_types enum
+	   from database.h but this is only for readability.
+	   This ldif_item struct allow use to define multiple
+	   LDIF field names ("attribute names") for one abook field */
+
+	{"cn",			NAME},		// 0
+	{"mail",		EMAIL},
+	{"streetaddress",	ADDRESS},
+	{"streetaddress2",	ADDRESS2},
+	{"locality",		CITY},
+	{"st",			STATE},
+	{"postalcode",		ZIP},
+	{"countryname",		COUNTRY},
+	{"homephone",		PHONE},
+	{"telephonenumber",	WORKPHONE},	// workphone, according to Mozilla
+	{"facsimiletelephonenumber",	FAX},
+	{"cellphone",		MOBILEPHONE},
+	{"mozillanickname",	NICK},
+	{"homeurl",		URL},
+	{"description",		NOTES},
+	{"anniversary",		ANNIVERSARY},
+	{"ou",			GROUPS},	// 16
+
+	// here comes a couple of aliases
+	{"mozillasecondemail",	EMAIL},
+	{"homecity",		CITY},
+	{"zip",			ZIP},
+	{"tel",			PHONE},
+	{"xmozillaanyphone",	WORKPHONE},	// ever used ?
+	{"workphone",		WORKPHONE},
+	{"fax",			FAX},
+	{"telexnumber",		FAX},
+	{"mobilephone",		MOBILEPHONE},
+	{"mobile",		MOBILEPHONE},
+	{"xmozillanickname",	NICK},
+	{"labeledURI",		URL},
+	{"notes",		NOTES},
+	{"birthday",		ANNIVERSARY},
+	{"category",		GROUPS},
+
+	/* TODO:
+	   "sn": append to lastname ?
+	   "surname": append to lastname ?
+	   "givenname": prepend to firstname ? */
+
+	/* here starts dummy fields:
+
+	   As long as additional indexes are created
+	   (using the above ldif_field_types),
+	   any other LDIF attr name can be added and
+	   used during ldif entry processing.
+	   But obviously fields > ITEM_FIELDS (database.h) won't be
+	   copied into the final *list_item. */
+
+	/* - to avoid mistake, don't use the special ITEM_FIELDS value.
+	   - see also: http://mxr.mozilla.org/comm-central/source/mailnews/addrbook/src/nsAbLDIFService.cpp */
+
+	// used to check valid LDIF records:
+	{"objectclass",		LDIF_OBJECTCLASS}
 };
+const int LDIF_IMPORTABLE_ITEM_FIELDS = (int)sizeof(ldif_conv_table)/sizeof(*ldif_conv_table);
 
-
+/*
+  Handles multi-line strings.
+  If a string starts with a space, it's the continuation
+  of the previous line. Thus we need to always read ahead.
+  But for this to work with stdin, we need to stores the next
+  line for later use in case it's not a continuation of the
+  first line.
+ */
 static char *
-ldif_read_line(FILE *in)
+ldif_read_line(FILE *in, char **next_line)
 {
 	char *buf = NULL;
 	char *ptr, *tmp;
-	long pos;
-	int i;
-
-	for(i = 1;;i++) {
-		char *line;
+	char *line;
+
+	// buf filled with the first line
+	if(!*next_line)
+		buf = getaline(in);
+	else {
+		buf = xstrdup(*next_line);
+		xfree(*next_line);
+	}
 
-		pos = ftell(in);
+	while(!feof(in)) {
+		// if no line already read-ahead.
 		line = getaline(in);
+		if(!line) break;
 
-		if(feof(in) || !line)
-			break;
-
-		if(i == 1) {
-			buf = line;
-			continue;
-		}
-
+		// this is not a continuation of what is already in buf
+		// store it for the next round
 		if(*line != ' ') {
-			fseek(in, pos, SEEK_SET); /* fixme ! */
-			free(line);
+			*next_line = line;
 			break;
 		}
 
+		// starts with ' ': this is the continuation of buf
 		ptr = line;
 		while( *ptr == ' ')
 			ptr++;
@@ -533,46 +672,90 @@ ldif_add_item(ldif_item li)
 	list_item item;
 	int i;
 
-	item = item_create();
-
-	if(!li[LDIF_ITEM_FIELDS -1])
+	/* if there's no value for "objectclass"
+	   it's probably a buggy record */
+	if(!li[LDIF_OBJECTCLASS])
 		goto bail_out;
 
-
-	for(i=0; i < LDIF_ITEM_FIELDS; i++) {
-		if(ldif_conv_table[i] >= 0 && li[i] && *li[i])
-			item_fput(item,ldif_conv_table[i],xstrdup(li[i]));
+	/* just copy from our extended ldif_item to a regular
+	   list_item,
+	   TODO: API could be changed so db_fput_byid() is usable */
+	item = item_create();
+	for(i=0; i < ITEM_FIELDS; i++) {
+		if(li[i] && *li[i])
+			item[i] = xstrdup(li[i]);
 	}
 
 	add_item2database(item);
+	item_free(&item);
 
 bail_out:
 	for(i=0; i < LDIF_ITEM_FIELDS; i++)
 		xfree(li[i]);
-	item_free(&item);
-
 }
 
 static void
 ldif_convert(ldif_item item, char *type, char *value)
 {
-	int i;
-
+	/* this is the first (mandatory) attribute to expected
+	   from a new valid LDIF record.
+	   The previous record must be added to the database before
+	   we can go further with the new one */
 	if(!strcmp(type, "dn")) {
 		ldif_add_item(item);
 		return;
 	}
 
-	for(i=0; i < LDIF_ITEM_FIELDS; i++) {
-		if(!safe_strcmp(ldif_field_names[i], type) && *value) {
-			if(i == LDIF_ITEM_FIELDS - 1) /* this is a dirty hack */
-				if(safe_strcmp("person", value))
-					break;
+	int i, index;
+
+	for( i=0; i < LDIF_IMPORTABLE_ITEM_FIELDS; i++ ) {
+
+		if( *value &&						// there's a value for the attr provided
+		    ldif_conv_table[i].key &&				// there exists an ldif attr name...
+		    !strcasecmp(ldif_conv_table[i].key, type)) {	// ...matching that provided at input
+
+			assert((i >= 0) && (i < LDIF_ITEM_FIELDS));
+			// which abook field this attribute's name maps to ?
+			index = ldif_conv_table[i].index;
+			assert((index >= 0) && (index < LDIF_ITEM_FIELDS));
+
+			/* TODO: here must be handled multi-valued cases
+			   (first or latest win, append or prepend values, ...)
+			   Currently: emails are appended, for other fields the
+			   first attribute found wins.
+			   Eg: the value of "mobile" will be taken into
+			   account if such a line comes before "cellphone". */
+
+			/* Remember: LDIF_ITEM_FIELDS > ITEM_FIELDS,
+			   lower (common) indexes of *ldif_item map well to *list_item.
+			   We can use item_fput()... */
+			if(index < ITEM_FIELDS) {
+				// multiple email support, but two only will stay
+				// in the final *list_item
+				if(index == EMAIL && item_fget(item, EMAIL)) {
+					item_fput(item,
+					          EMAIL,
+					          strconcat(item_fget(item, EMAIL), ",", value, 0));
+				}
+				else {
+					/* Don't override already initialized fields:
+					   This is the rule of the "first win" */
+					if(! item_fget(item, index))
+						item_fput(item, index, xstrdup(value));
+				}
+			}
 
-			if(item_fget(item, i))
-				free(item_fget(item, i));
+			/* ... but if the ldif field's name index is higher
+			   than what standards abook fields struct can hold,
+			   these extra indexes must be managed manually.
+			   This is the case of LDIF_OBJECTCLASS ("objectclass" attr) */
+			else {
+				item[index] = xstrdup(value);
+			}
 
-			item_fput(item, i, xstrdup(value));
+			// matching attr found and field filled:
+			// no further attr search is needed for `type`
+	                break;
 		}
 	}
 }
@@ -581,46 +764,40 @@ static int
 ldif_parse_file(FILE *handle)
 {
 	char *line = NULL;
+	char *next_line = NULL;
 	char *type, *value;
 	int vlen;
+
+	/* This is our extended fields holder to put the values from
+	   successfully parsed LDIF attributes.
+	   ldif_item item is temporary. When the end of an entry is reached,
+	   values are copied into a regular *list_item struct, see ldif_add_item() */
 	ldif_item item;
 
 	memset(item, 0, sizeof(item));
 
 	do {
-		if( !(line = ldif_read_line(handle)) )
-			continue;
+		line = ldif_read_line(handle, &next_line);
+
+		// EOF or empty lines: continue;
+		if(!line || *line == '\0') continue;
 
 		if(-1 == (str_parse_line(line, &type, &value, &vlen))) {
 			xfree(line);
 			continue; /* just skip the errors */
 		}
 
-		ldif_fix_string(value);
-
 		ldif_convert(item, type, value);
 
 		xfree(line);
 	} while ( !feof(handle) );
 
+	// force registration (= ldif_add_item()) of the last LDIF entry
 	ldif_convert(item, "dn", "");
 
 	return 0;
 }
 
-static void
-ldif_fix_string(char *str)
-{
-	int i, j;
-
-	for(i = 0, j = 0; j < (int)strlen(str); i++, j++)
-		str[i] = ( str[j] == (char)0xc3 ?
-				(char) str[++j] + (char) 0x40 :
-				str[j] );
-
-	str[i] = 0;
-}
-
 /*
  * end of ldif import
  */
@@ -632,10 +809,11 @@ ldif_fix_string(char *str)
 #include "getname.h"
 
 static int
-mutt_read_line(FILE *in, char **alias, char **rest)
+mutt_read_line(FILE *in, char **groups, char **alias, char **rest)
 {
-	char *line, *ptr, *tmp;
-	size_t alias_len;
+	char *line, *ptr;
+	char *start, *end;
+	abook_list *glist = NULL;
 
 	if( !(line = ptr = getaline(in)) )
 		return 1; /* error / EOF */
@@ -648,27 +826,39 @@ mutt_read_line(FILE *in, char **alias, char **rest)
 	}
 
 	ptr += 5;
-
 	SKIPWS(ptr);
 
-	tmp = ptr;
-
-	while( ! ISSPACE(*ptr) )
-		ptr++;
-
-	alias_len = (size_t)(ptr - tmp);
+	/* If the group option is used, save the groups */
+	*groups = NULL;
+	start = ptr;
+	int n_groups;
+	for(n_groups = 0; 0 == strncmp("-group", ptr, 6); n_groups++) {
+		ptr += 6;
+		SKIPWS(ptr);
+		start = ptr;
+		SKIPNONWS(ptr);
+		end = ptr;
+		abook_list_append(&glist,xstrndup(start, end - start));
+		SKIPWS(ptr);
+	}
 
-	if(alias)
-		*alias = xmalloc_inc(alias_len, 1);
+	if(n_groups && groups)
+		*groups = abook_list_to_csv(glist);
 
-	strncpy(*alias, tmp, alias_len);
-	*(*alias + alias_len) = 0;
+	abook_list_free(&glist);	
 
+	/* alias */
+	start = ptr;
+	SKIPNONWS(ptr);
+	end = ptr;
 	SKIPWS(ptr);
+	if(alias)
+		*alias = xstrndup(start, end - start);
 
+	/* rest (email) */
 	*rest = xstrdup(ptr);
 
-	free(line);
+	xfree(line);
 	return 0;
 }
 
@@ -749,9 +939,9 @@ mutt_parse_file(FILE *in)
 		memset(item, 0, fields_count * sizeof(char *));
 
 		if(!mutt_read_line(in,
-					(field_id(NICK) != -1) ?
-					&item[field_id(NICK)] :	NULL,
-					&item[field_id(NAME)]))
+			(field_id(GROUPS) != -1) ? &item[field_id(GROUPS)] : NULL,
+			(field_id(NICK) != -1) ? &item[field_id(NICK)] : NULL,
+			&item[field_id(NAME)]) )
 			mutt_parse_email(item);
 
 		if(feof(in)) {
@@ -791,6 +981,7 @@ static int
 ldif_export_database(FILE *out, struct db_enumerator e)
 {
 	char email[MAX_EMAILSTR_LEN];
+	abook_list *emails, *em;
 
 	fprintf(out, "version: 1\n");
 
@@ -799,21 +990,32 @@ ldif_export_database(FILE *out, struct db_enumerator e)
 		int j;
 		get_first_email(email, e.item);
 
-		tmp = strdup_printf("cn=%s,mail=%s",db_name_get(e.item),email);
+		if(*email)
+			tmp = strdup_printf("cn=%s,mail=%s",db_name_get(e.item),email);
+		/* TODO: this may not be enough for a trully "Distinguished" name
+		   needed by LDAP. Appending a random uuid could do the trick */
+		else
+			tmp = strdup_printf("cn=%s",db_name_get(e.item));
 
 		ldif_fput_type_and_value(out, "dn", tmp);
 		free(tmp);
 
-		for(j = 0; j < LDIF_ITEM_FIELDS; j++) {
-			if(ldif_conv_table[j] >= 0) {
-				if(ldif_conv_table[j] == EMAIL)
-					ldif_fput_type_and_value(out,
-						ldif_field_names[j], email);
-				else if(db_fget(e.item,ldif_conv_table[j]))
-					ldif_fput_type_and_value(out,
-						ldif_field_names[j],
-						db_fget(e.item,
-							ldif_conv_table[j]));
+		for(j = 0; j < ITEM_FIELDS; j++) {
+			if(j == EMAIL) {
+				if(*email) {
+					tmp = db_email_get(e.item);
+					emails = csv_to_abook_list(tmp);
+					free(tmp);
+					for(em = emails; em; em = em->next)
+						ldif_fput_type_and_value(out,
+						                         ldif_field_names[EMAIL],
+						                         em->data);
+				}
+			}
+			else if(db_fget(e.item,j)) {
+				ldif_fput_type_and_value(out,
+				                         ldif_field_names[j],
+				                         db_fget(e.item, j));
 			}
 		}
 
@@ -832,37 +1034,56 @@ ldif_export_database(FILE *out, struct db_enumerator e)
  * html export filter
  */
 
-static void            html_export_write_head(FILE *out, int extra_column);
+static void            html_export_write_head(FILE *out);
 static void            html_export_write_tail(FILE *out);
 
+extern struct index_elem *index_elements;
+
+static void
+html_print_emails(FILE *out, struct list_field *f)
+{
+	abook_list *l = csv_to_abook_list(f->data);
+
+	for(; l; l = l->next) {
+		fprintf(out, "<a href=\"mailto:%s\">%s</a>", l->data, l->data);
+		if(l->next)
+			fprintf(out, ", ");
+	}
+
+	abook_list_free(&l);
+}
+
 static int
 html_export_database(FILE *out, struct db_enumerator e)
 {
-	char tmp[MAX_EMAILSTR_LEN];
-	int extra_column;
+	struct list_field f;
+	struct index_elem *cur;
 
 	if(list_is_empty())
 		return 2;
 
-	extra_column = init_extra_field(STR_EXTRA_COLUMN);
-	html_export_write_head(out, extra_column);
+	init_index();
 
-	db_enumerate_items(e) {
-		get_first_email(tmp, e.item);
-		if (*tmp)
-		    fprintf(out, "<tr>\n<td>"
-				    "<a href=\"mailto:%s\">%s</a>"
-				    "</td>\n",
-			    tmp,
-			    db_name_get(e.item));
-		else
-		    fprintf(out, "<tr>\n<td>%s</td>\n", db_name_get(e.item));
+	html_export_write_head(out);
 
-		fprintf(out, "<td>%s</td>\n", db_email_get(e.item));
-		if(extra_column >= 0)
-			fprintf(out, "<td>%s</td>\n",
-				safe_str(db_fget_byid(e.item, extra_column)));
-		fprintf(out, "</tr>\n\n");
+	db_enumerate_items(e) {
+		fprintf(out, "<tr>");
+		for(cur = index_elements; cur; cur = cur->next) {
+			if(cur->type != INDEX_FIELD)
+				continue;
+
+			get_list_field(e.item, cur, &f);
+
+			if(f.type == FIELD_EMAILS) {
+				fprintf(out, "<td>");
+				html_print_emails(out, &f);
+				fprintf(out, "</td>");
+				continue;
+			} else {
+				fprintf(out, "<td>%s</td>", safe_str(f.data));
+			}
+		}
+		fprintf(out, "</tr>\n");
 	}
 
 	html_export_write_tail(out);
@@ -871,9 +1092,10 @@ html_export_database(FILE *out, struct db_enumerator e)
 }
 
 static void
-html_export_write_head(FILE *out, int extra_column)
+html_export_write_head(FILE *out)
 {
-	char *realname = get_real_name(), *extra_column_name = NULL;
+	char *realname = get_real_name(), *str;
+	struct index_elem *cur;
 
 	fprintf(out, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n");
 	fprintf(out, "<html>\n<head>\n <title>%s's addressbook</title>",
@@ -882,11 +1104,13 @@ html_export_write_head(FILE *out, int extra_column)
 	fprintf(out, "\n<h2>%s's addressbook</h2>\n", realname );
 	fprintf(out, "<br><br>\n\n");
 
-	fprintf(out, "<table border=\"1\" align=\"center\">\n");
-	fprintf(out, "\n<tr><th>Name</th><th>E-mail address(es)</th>");
-	if(extra_column >= 0) {
-		get_field_keyname(extra_column, NULL, &extra_column_name);
-		fprintf(out, "<th>%s</th>", safe_str(extra_column_name));
+	fprintf(out, "<table border=\"1\" align=\"center\">\n<tr>");
+	for(cur = index_elements; cur; cur = cur->next) {
+		if(cur->type != INDEX_FIELD)
+			continue;
+
+		get_field_info(cur->d.field.id, NULL, &str, NULL);
+		fprintf(out, "<th>%s</th>", str);
 	}
 	fprintf(out, "</tr>\n\n");
 
@@ -916,7 +1140,7 @@ pine_fixbuf(char *buf)
 {
 	int i,j;
 
-	for(i=0,j=0; j < (int)strlen(buf); i++, j++)
+	for(i = 0,j = 0; j < (int)strlen(buf); i++, j++)
 		buf[i] = buf[j] == '\n' ? buf[++j] : buf[j];
 }
 
@@ -929,15 +1153,15 @@ pine_convert_emails(char *s)
 	if(s == NULL || *s != '(')
 		return;
 
-	for(i=0; s[i]; i++ )
-		s[i] = s[i+1];
+	for(i = 0; s[i]; i++)
+		s[i] = s[i + 1];
 
 	if( ( tmp = strchr(s,')')) )
-		*tmp=0;
+		*tmp = '\0';
 
 	for(i = 1; ( tmp = strchr(s, ',') ) != NULL ; i++, s = tmp + 1)
 		if(i > MAX_LIST_ITEMS - 1) {
-			*tmp = 0;
+			*tmp = '\0';
 			break;
 		}
 
@@ -1035,14 +1259,18 @@ pine_parse_file(FILE *in)
 static int
 pine_export_database(FILE *out, struct db_enumerator e)
 {
+	char *emails;
+
 	db_enumerate_items(e) {
-		fprintf(out, have_multiple_emails(e.item) ?
+		emails = db_email_get(e.item);
+		fprintf(out, strchr(emails, ',') /* multiple addresses? */ ?
 				"%s\t%s\t(%s)\t\t%s\n" : "%s\t%s\t%s\t\t%s\n",
 				safe_str(db_fget(e.item, NICK)),
 				safe_str(db_name_get(e.item)),
-				safe_str(db_email_get(e.item)),
+				emails,
 				safe_str(db_fget(e.item, NOTES))
 				);
+		free(emails);
 	}
 
 	return 0;
@@ -1302,6 +1530,278 @@ palmcsv_parse_file(FILE *in)
  * end of csv import filter
  */
 
+/*
+ * vCard import filter
+ */
+
+static char *vcard_fields[] = {
+	"FN",			/* FORMATTED NAME */
+	"EMAIL",		/* EMAIL */
+	"ADR",			/* ADDRESS */
+	"ADR",			/* ADDRESS2 - not used */
+	"ADR",			/* CITY */
+	"ADR",			/* STATE */
+	"ADR",			/* ZIP */
+	"ADR",			/* COUNTRY */
+	"TEL",			/* PHONE */
+	"TEL",			/* WORKPHONE */
+	"TEL",			/* FAX */
+	"TEL",			/* MOBILEPHONE */
+	"NICKNAME",		/* NICK */
+	"URL",			/* URL */
+	"NOTE",			/* NOTES */
+	"N",			/* NAME: special case/mapping in vcard_parse_line() */
+	NULL			/* not implemented: ANNIVERSARY, ITEM_FIELDS */
+};
+
+/*
+ * mappings between vCard ADR field and abook's ADDRESS
+ * see rfc2426 section 3.2.1
+ */
+static int vcard_address_fields[] = {
+	-1,			/* vCard(post office box) - not used */
+	-1,			/* vCard(the extended address) - not used */
+	2,			/* vCard(the street address) - ADDRESS */
+	4,			/* vCard(the locality) - CITY */
+	5,			/* vCard(the region) - STATE */
+	6,			/* vCard(the postal code) - ZIP */
+	7			/* vCard(the country name) - COUNTRY */
+};
+
+enum {
+	VCARD_KEY = 0,
+	VCARD_KEY_ATTRIBUTE,
+	VCARD_VALUE,
+};
+
+static char *
+vcard_get_line_element(char *line, int element)
+{
+	int i;
+	char *line_copy = 0;
+	char *result = 0;
+	char *key = 0;
+	char *key_attr = 0;
+	char *value = 0;
+
+	line_copy = xstrdup(line);
+
+	/* change newline characters, if present, to end of string */
+	for(i=0; line_copy[i]; i++) {
+		if(line_copy[i] == '\r' || line_copy[i] == '\n') {
+			line_copy[i] = '\0';
+			break;
+		}
+	}
+
+	/* separate key from value */
+	for(i=0; line_copy[i]; i++) {
+		if(line_copy[i] == ':') {
+			line_copy[i] = '\0';
+			key = line_copy;
+			value = &line_copy[i+1];
+			break;
+		}
+	}
+
+	/* separate key from key attributes */
+	/* works for vCard 2 as well (automagically) */
+	if (key) {
+		for(i=0; key[i]; i++) {
+			if(key[i] == ';') {
+				key[i] = '\0';
+				key_attr = &key[i+1];
+				break;
+			}
+		}
+	}
+
+	switch(element) {
+	case VCARD_KEY:
+		if(key)
+			result = xstrdup(key);
+		break;
+	case VCARD_KEY_ATTRIBUTE:
+		if(key_attr)
+			result = xstrdup(key_attr);
+		break;
+	case VCARD_VALUE:
+		if(value)
+			result = xstrdup(value);
+		break;
+	}
+
+	xfree(line_copy);
+	return result;
+}
+
+static void
+vcard_parse_email(list_item item, char *line)
+{
+	char *email;
+
+	email = vcard_get_line_element(line, VCARD_VALUE);
+
+	if(item[1]) {
+		item[1] = strconcat(item[1], ",", email, 0);
+		xfree(email);
+	}
+	else {
+		item[1] = email;
+	}
+}
+
+static void
+vcard_parse_address(list_item item, char *line)
+{
+	int i;
+	int k;
+	char *value;
+	char *address_field;
+
+	value = vcard_get_line_element(line, VCARD_VALUE);
+	if(!value)
+		return;
+
+	address_field = value;
+	for(i=k=0; value[i]; i++) {
+		if(value[i] == ';') {
+			value[i] = '\0';
+			if(vcard_address_fields[k] >= 0) {
+				item[vcard_address_fields[k]] = xstrdup(address_field);
+			}
+			address_field = &value[i+1];
+			k++;
+			if((k+1)==(sizeof(vcard_address_fields)/sizeof(*vcard_address_fields)))
+				break;
+		}
+	}
+	item[vcard_address_fields[k]] = xstrdup(address_field);
+	xfree(value);
+}
+
+static void
+vcard_parse_name(list_item item, char *line)
+{
+	// store the "N" field into "NAME" *if* no "FN:"
+	// value has already been stored here
+	if(item[0]) return;
+
+	int i = -1;
+	item[0] = vcard_get_line_element(line, VCARD_VALUE);
+	// "N:" can be multivalued => replace ';' separators by ' '
+	while(item[0][++i]) if(item[0][i] == ';') item[0][i] = ' ';
+
+	// http://www.daniweb.com/software-development/c/code/216919
+	char *original = item[0], *p = original;
+	int trimmed = 0;
+	do {
+	  if (*original != ' ' || trimmed) {
+	    trimmed = 1; *p++ = *original;
+	  }
+	} while(*original++);
+}
+
+static void
+vcard_parse_phone(list_item item, char *line)
+{
+	char *type = vcard_get_line_element(line, VCARD_KEY_ATTRIBUTE);
+	char *value = vcard_get_line_element(line, VCARD_VALUE);
+
+	/* set the standard number */
+	if (!type) item_fput(item, PHONE, value);
+
+	/*
+	 * see rfc2426 section 3.3.1
+	 * Note: we probably support both vCard 2 and 3
+	 */
+	else {
+		if (strcasestr(type, "home") != NULL)
+			item_fput(item, PHONE, xstrdup(value));
+		else if (strcasestr(type, "work") != NULL)
+			item_fput(item, WORKPHONE, xstrdup(value));
+		else if (strcasestr(type, "fax") != NULL)
+			item_fput(item, FAX, xstrdup(value));
+		else if (strcasestr(type, "cell") != NULL)
+			item_fput(item, MOBILEPHONE, xstrdup(value));
+
+		xfree(type);
+		xfree(value);
+	}
+}
+
+static void
+vcard_parse_line(list_item item, char *line)
+{
+	int i;
+	char *key;
+
+	for(i=0; vcard_fields[i]; i++) {
+		key = vcard_fields[i];
+
+		if(0 == strncmp(key, line, strlen(key))) {
+			if(0 == strcmp(key, "EMAIL"))
+				vcard_parse_email(item, line);
+			else if(i == 2)
+				vcard_parse_address(item, line);
+			else if(0 == strcmp(key, "TEL"))
+				vcard_parse_phone(item, line);
+			else if(0 == strcmp(key, "N"))
+				vcard_parse_name(item, line);
+			else
+				item[i] = vcard_get_line_element(line, VCARD_VALUE);
+			return;
+		}
+	}
+}
+
+static void
+vcard_parse_item(FILE *in)
+{
+	char *line = NULL;
+	list_item item = item_create();
+
+	while(!feof(in)) {
+		line = getaline(in);
+
+		if(line && !strncmp("END:VCARD", line, 9)) {
+			xfree(line);
+			break;
+		}
+		else if(line) {
+			vcard_parse_line(item, line);
+			xfree(line);
+		}
+	}
+
+	add_item2database(item);
+	item_free(&item);
+}
+
+static int
+vcard_parse_file(FILE *in)
+{
+	char *line = NULL;
+
+	while(!feof(in)) {
+		line = getaline(in);
+
+		if(line && !strncmp("BEGIN:VCARD", line, 11)) {
+			xfree(line);
+			vcard_parse_item(in);
+		}
+		else if(line) {
+			xfree(line);
+		}
+	}
+
+	return 0;
+}
+
+/*
+ * end of vCard import filter
+ */
+
 /*
  * csv addressbook export filters
  */
@@ -1384,6 +1884,7 @@ allcsv_export_database(FILE *out, struct db_enumerator e)
 		URL,
 		NOTES,
 		ANNIVERSARY,
+		GROUPS,
 		CSV_LAST
 	};
 
@@ -1403,7 +1904,8 @@ allcsv_export_database(FILE *out, struct db_enumerator e)
 	fprintf(out, "\"NICK\",");
 	fprintf(out, "\"URL\",");
 	fprintf(out, "\"NOTES\",");
-	fprintf(out, "\"ANNIVERSARY\"\n");
+	fprintf(out, "\"ANNIVERSARY\",");
+	fprintf(out, "\"GROUPS\"\n");
 
 	csv_export_common(out, e, allcsv_export_fields, NULL);
 
@@ -1492,81 +1994,86 @@ palm_export_database(FILE *out, struct db_enumerator e)
  */
 
 /*
- * GnomeCard (VCard) addressbook export filter
+ * vCard 2 addressbook export filter
  */
 
 static int
-gcrd_export_database(FILE *out, struct db_enumerator e)
+vcard_export_database(FILE *out, struct db_enumerator e)
+{
+  db_enumerate_items(e)
+    vcard_export_item(out, e.item);
+  return 0;
+}
+
+void
+vcard_export_item(FILE *out, int item)
 {
 	int j;
-	char *name;
+	char *name, *tmp;
 	abook_list *emails, *em;
+	fprintf(out, "BEGIN:VCARD\r\nFN:%s\r\n",
+		safe_str(db_name_get(item)));
 
-	db_enumerate_items(e) {
-		fprintf(out, "BEGIN:VCARD\nFN:%s\n",
-				safe_str(db_name_get(e.item)));
-
-		name = get_surname(db_name_get(e.item));
-	        for( j = strlen(db_name_get(e.item)) - 1; j >= 0; j-- ) {
-	                if((db_name_get(e.item))[j] == ' ')
-	                        break;
-	        }
-		fprintf(out, "N:%s;%.*s\n",
-			safe_str(name),
-			j,
-			safe_str(db_name_get(e.item))
-			);
-
-		free(name);
-
-		if(db_fget(e.item, ADDRESS))
-			fprintf(out, "ADR:;;%s;%s;%s;%s;%s;%s\n",
-				safe_str(db_fget(e.item, ADDRESS)),
-				safe_str(db_fget(e.item, ADDRESS2)),
-				safe_str(db_fget(e.item, CITY)),
-				safe_str(db_fget(e.item, STATE)),
-				safe_str(db_fget(e.item, ZIP)),
-				safe_str(db_fget(e.item, COUNTRY))
-				);
-
-		if(db_fget(e.item, PHONE))
-			fprintf(out, "TEL;HOME:%s\n",
-					db_fget(e.item, PHONE));
-		if(db_fget(e.item, WORKPHONE))
-			fprintf(out, "TEL;WORK:%s\n",
-					db_fget(e.item, WORKPHONE));
-		if(db_fget(e.item, FAX))
-			fprintf(out, "TEL;FAX:%s\n",
-					db_fget(e.item, FAX));
-		if(db_fget(e.item, MOBILEPHONE))
-			fprintf(out, "TEL;CELL:%s\n",
-					db_fget(e.item, MOBILEPHONE));
-
-		if(*db_email_get(e.item)) {
-			emails = csv_to_abook_list(db_email_get(e.item));
-
-			for(em = emails; em; em = em->next)
-				fprintf(out, "EMAIL;INTERNET:%s\n", em->data);
-
-			abook_list_free(&emails);
-		}
-
-		if(db_fget(e.item, NOTES))
-			fprintf(out, "NOTE:%s\n",
-					db_fget(e.item, NOTES));
-		if(db_fget(e.item, URL))
-			fprintf(out, "URL:%s\n",
-					db_fget(e.item, URL));
+	name = get_surname(db_name_get(item));
+	for( j = strlen(db_name_get(item)) - 1; j >= 0; j-- ) {
+	  if((db_name_get(item))[j] == ' ')
+	    break;
+	}
+	fprintf(out, "N:%s;%.*s\r\n",
+		safe_str(name),
+		j,
+		safe_str(db_name_get(item))
+		);
+
+	free(name);
+
+	if(db_fget(item, ADDRESS))
+	  fprintf(out, "ADR:;;%s;%s;%s;%s;%s;%s\r\n",
+		  safe_str(db_fget(item, ADDRESS)),
+		  safe_str(db_fget(item, ADDRESS2)),
+		  safe_str(db_fget(item, CITY)),
+		  safe_str(db_fget(item, STATE)),
+		  safe_str(db_fget(item, ZIP)),
+		  safe_str(db_fget(item, COUNTRY))
+		  );
+
+	if(db_fget(item, PHONE))
+	  fprintf(out, "TEL;HOME:%s\r\n",
+		  db_fget(item, PHONE));
+	if(db_fget(item, WORKPHONE))
+	  fprintf(out, "TEL;WORK:%s\r\n",
+		  db_fget(item, WORKPHONE));
+	if(db_fget(item, FAX))
+	  fprintf(out, "TEL;FAX:%s\r\n",
+		  db_fget(item, FAX));
+	if(db_fget(item, MOBILEPHONE))
+	  fprintf(out, "TEL;CELL:%s\r\n",
+		  db_fget(item, MOBILEPHONE));
+
+	tmp = db_email_get(item);
+	if(*tmp) {
+	  emails = csv_to_abook_list(tmp);
+
+	  for(em = emails; em; em = em->next)
+	    fprintf(out, "EMAIL;INTERNET:%s\r\n", em->data);
+
+	  abook_list_free(&emails);
+	}
+	free(tmp);
 
-		fprintf(out, "END:VCARD\n\n");
+	if(db_fget(item, NOTES))
+	  fprintf(out, "NOTE:%s\r\n",
+		  db_fget(item, NOTES));
+	if(db_fget(item, URL))
+	  fprintf(out, "URL:%s\r\n",
+		  db_fget(item, URL));
 
-	}
+	fprintf(out, "END:VCARD\r\n\r\n");
 
-	return 0;
 }
 
 /*
- * end of GnomeCard export filter
+ * end of vCard export filter
  */
 
 
@@ -1592,25 +2099,128 @@ mutt_alias_genalias(int i)
 	return tmp;
 }
 
+/*
+ * This function is a variant of abook_list_to_csv
+ * */
+static char *
+mutt_alias_gengroups(int i)
+{
+	char *groups, *res = NULL;
+	char groupstr[7] = "-group ";
+	abook_list *list, *tmp;
+
+	groups = db_fget(i, GROUPS);
+
+	if(!groups)
+		return NULL;
+
+	list = csv_to_abook_list(groups);
+	for(tmp = list; tmp; tmp = tmp->next) {
+		if(tmp == list) {
+			res = xmalloc(strlen(groupstr)+strlen(tmp->data)+1);
+			res = strcpy(res, groupstr);
+		} else {
+			res = xrealloc(res, strlen(res)+1+strlen(groupstr)+strlen(tmp->data)+1);
+			strcat(res, " ");
+			strcat(res, groupstr);
+		}
+		strcat(res, tmp->data);
+	}
+	abook_list_free(&list);
+	xfree(groups);
+
+	return res;
+}
+
 static int
 mutt_alias_export(FILE *out, struct db_enumerator e)
 {
 	char email[MAX_EMAIL_LEN];
 	char *alias = NULL;
+	char *groups = NULL;
+	int email_addresses;
+	char *ptr;
 
 	db_enumerate_items(e) {
-		alias = mutt_alias_genalias(e.item);
+		alias = (field_id(NICK) != -1) ? mutt_alias_genalias(e.item) : NULL;
+		groups = (field_id(GROUPS) != -1) ?  mutt_alias_gengroups(e.item) : NULL;
 		get_first_email(email, e.item);
-		fprintf(out, *email ? "alias %s %s <%s>\n": "alias %s %s%s\n",
-				alias,
-				db_name_get(e.item),
-				email);
-		xfree(alias);
+
+		/* do not output contacts without email address */
+		/* cause this does not make sense in mutt aliases */
+		if (*email) {
+
+			/* output first email address */
+			fprintf(out,"alias ");
+			if(groups)
+				fprintf(out, "%s ", groups);
+			if(alias)
+				fprintf(out, "%s ", alias);
+			fprintf(out, "%s <%s>\n",
+					db_name_get(e.item),
+					email);
+
+			/* number of email addresses */
+			email_addresses = 1;
+			ptr = db_email_get(e.item);
+			while (*ptr != '\0') {
+				if (*ptr == ',') {
+					email_addresses++;
+				}
+				ptr++;
+			}
+
+			/* output other email addresses */
+			while (email_addresses-- > 1) {
+				roll_emails(e.item, ROTATE_RIGHT);
+				get_first_email(email, e.item);
+				fprintf(out,"alias ");
+				if( groups )
+					fprintf(out, "%s ", groups);
+				if(alias)
+					fprintf(out, "%s__%s ", alias, email);
+				else
+					fprintf(out, "%s__%s ", db_name_get(e.item), email);
+				fprintf(out, "%s <%s>\n",
+						db_name_get(e.item),
+						email);
+			}
+			roll_emails(e.item, ROTATE_RIGHT);
+			xfree(alias);
+			xfree(groups);
+		}
 	}
 
 	return 0;
 }
 
+void muttq_print_item(FILE *file, int item)
+{
+	abook_list *emails, *e;
+	char *tmp = db_email_get(item);
+
+	emails = csv_to_abook_list(tmp);
+	free(tmp);
+
+	for(e = emails; e; e = e->next) {
+		fprintf(file, "%s\t%s\t%s\n", e->data, db_name_get(item),
+				!db_fget(item, NOTES) ?" " :db_fget(item, NOTES)
+				);
+		if(!opt_get_bool(BOOL_MUTT_RETURN_ALL_EMAILS))
+			break;
+	}
+	abook_list_free(&emails);
+}
+
+static int
+mutt_query_export_database(FILE *out, struct db_enumerator e)
+{
+  fprintf(out, "All items\n");
+  db_enumerate_items(e)
+    muttq_print_item(out, e.item);
+  return 0;
+}
+
 /*
  * end of mutt alias export filter
  */
@@ -1689,7 +2299,7 @@ text_export_database(FILE * out, struct db_enumerator e)
 {
 	abook_list *emails, *em;
 	int j;
-	char *realname = get_real_name(), *str = NULL;
+	char *realname = get_real_name(), *str = NULL, *tmp;
 	char *style = opt_get_str(STR_ADDRESS_STYLE);
 
 	fprintf(out,
@@ -1706,8 +2316,9 @@ text_export_database(FILE * out, struct db_enumerator e)
 			fprintf(out, "\n(%s)", db_fget(e.item, NICK));
 		fprintf(out, "\n");
 
-		if(*db_email_get(e.item)) {
-			emails = csv_to_abook_list(db_email_get(e.item));
+		tmp = db_email_get(e.item);
+		if(*tmp) {
+			emails = csv_to_abook_list(tmp);
 
 			fprintf(out, "\n");
 			for(em = emails; em; em = em->next)
@@ -1715,6 +2326,7 @@ text_export_database(FILE * out, struct db_enumerator e)
 
 			abook_list_free(&emails);
 		}
+		free(tmp);
 		/* Print address */
 		if(db_fget(e.item, ADDRESS)) {
 			if(!safe_strcmp(style, "us"))	/* US like */
@@ -1734,8 +2346,8 @@ text_export_database(FILE * out, struct db_enumerator e)
 			fprintf(out, "\n");
 			for(j = PHONE; j <= MOBILEPHONE; j++)
 				if(db_fget(e.item, j)) {
-					get_field_keyname(field_id(j),
-							NULL, &str);
+					get_field_info(field_id(j),
+							NULL, &str, NULL);
 					fprintf(out, "%s: %s\n", str,
 						db_fget(e.item, j));
 				}
@@ -1795,8 +2407,8 @@ spruce_export_database (FILE *out, struct db_enumerator e)
 	fprintf(out, "# This is a generated file made by abook for the Spruce e-mail client.\n\n");
 
 	db_enumerate_items(e) {
-		if(strcmp(safe_str(db_email_get(e.item)), "")) {
-			get_first_email(email, e.item);
+		get_first_email(email, e.item);
+		if(strcmp(email, "")) {
 			fprintf(out, "# Address %d\nName: %s\nEmail: %s\nMemo: %s\n\n",
 					e.item,
 					db_name_get(e.item),
@@ -1822,19 +2434,19 @@ spruce_export_database (FILE *out, struct db_enumerator e)
 static int
 wl_export_database(FILE *out, struct db_enumerator e)
 {
-	abook_list *emails;
+	char email[MAX_EMAIL_LEN];
 
 	fprintf(out, "# Wanderlust address book written by %s\n\n", PACKAGE);
 	db_enumerate_items(e) {
-		if((emails = csv_to_abook_list(db_email_get(e.item))) != NULL) {
+		get_first_email(email, e.item);
+		if(*email) {
 			fprintf(out,
 				"%s\t\"%s\"\t\"%s\"\n",
-				emails->data,
+				email,
 				safe_str(db_fget(e.item, NICK)),
 				safe_str(db_name_get(e.item))
 			);
 		}
-		abook_list_free(&emails);
 	}
 
 	fprintf (out, "\n# End of address book file.\n");
@@ -1846,3 +2458,212 @@ wl_export_database(FILE *out, struct db_enumerator e)
  * end of wanderlust addressbook export filter
  */
 
+/*
+ * BSD calendar export filter
+ */
+
+static int
+bsdcal_export_database(FILE *out, struct db_enumerator e)
+{
+	db_enumerate_items(e) {
+		int year, month = 0, day = 0;
+		char *anniversary = db_fget(e.item, ANNIVERSARY);
+
+		if(anniversary) {
+			if(!parse_date_string(anniversary, &day, &month, &year))
+				continue;
+
+			fprintf(out,
+				_("%02d/%02d\tAnniversary of %s\n"),
+				month,
+				day,
+				safe_str(db_name_get(e.item))
+			);
+		}
+	}
+
+	return 0;
+}
+
+// see also enum field_types @database.h
+extern abook_field standard_fields[];
+static int
+find_field_enum(char *s) {
+	int i = -1;
+	while(standard_fields[++i].key)
+		if(!strcmp(standard_fields[i].key, s))
+			return i;
+	return -1;
+}
+
+/* Convert a string with named placeholders to
+   a *printf() compatible string.
+   Stores the abook field values into ft. */
+void
+parse_custom_format(char *s, char *fmt_string, enum field_types *ft)
+{
+	if(! fmt_string || ! ft) {
+	  fprintf(stderr, _("parse_custom_format: fmt_string or ft not allocated\n"));
+	  exit(EXIT_FAILURE);
+	}
+
+	char tmp[1] = { 0 };
+	char *p, *start, *field_name = NULL;
+	p = start = s;
+
+	while(*p) {
+		if(*p == '{') {
+		  start = ++p;
+
+		  if(! *start) goto cannotparse;
+		  p = strchr(start, '}');
+		  if(! p) goto cannotparse;
+		  strcat(fmt_string, "%s");
+		  field_name = strndup(start, (size_t)(p-start));
+		  *ft = find_field_enum(field_name);
+		  if(*ft == -1) {
+		    fprintf(stderr, _("parse_custom_format: invalid placeholder: {%s}\n"), field_name);
+		    exit(EXIT_FAILURE);
+		  }
+
+		  ft++;
+		  start = ++p;
+		}
+
+		else if(*p == '\\') {
+			++p;
+			if(! *p) tmp[0] = '\\'; // last char is a '\' ?
+			else if(*p == 'n') *tmp = '\n';
+			else if(*p == 't') *tmp = '\t';
+			else if(*p == 'r') *tmp = '\r';
+			else if(*p == 'v') *tmp = '\v';
+			else if(*p == 'b') *tmp = '\b';
+			else if(*p == 'a') *tmp = '\a';
+			else *tmp = *p;
+			strncat(fmt_string, tmp, 1);
+			start = ++p;
+		}
+
+		// if no '\' following: quick mode using strchr/strncat
+		else if(! strchr(start, '\\')) {
+		  p = strchr(start, '{');
+		  if(p) { // copy until the next placeholder
+		    strncat(fmt_string, start, (size_t)(p-start));
+		    start = p;
+		  }
+		  else { // copy till the end
+		    strncat( fmt_string,
+			     start,
+			     FORMAT_STRING_LEN - strlen(fmt_string) - 1 );
+		    break;
+		  }
+		}
+
+		// otherwise character by character
+		else {
+			strncat(fmt_string, p, 1);
+			start = ++p;
+		}
+	}
+
+	*ft = ITEM_FIELDS;
+	return;
+
+ cannotparse:
+	fprintf(stderr, _("%s: invalid format, index %ld\n"), __FUNCTION__, (start - s));
+	free(fmt_string);
+	while(*ft) free(ft--);
+	exit(EXIT_FAILURE);
+}
+
+static int
+custom_export_item(FILE *out, int item, char *s, enum field_types *ft);
+
+
+// used to store the format string from --outformatstr when "custom" format is used
+// default value overriden in export_file()
+extern char *parsed_custom_format;
+extern enum field_types *custom_format_fields;
+
+/* wrapper for custom_export_item:
+   1) avoid messing with extern pointer
+   2) adds \n
+   3) follow the prototype needed for an abook_output_item_filter entry */
+void
+custom_print_item(FILE *out, int item)
+{
+
+  if(custom_export_item(out, item, parsed_custom_format, custom_format_fields) == 0)
+    fprintf(out, "\n");
+}
+
+static int
+custom_export_item(FILE *out, int item, char *fmt, enum field_types *ft)
+{
+  char *p, *q = 0;
+
+  // if the first character is '!':
+  // we first check that all fields exist before continuing
+  if(*fmt == '!') {
+    enum field_types *ftp = ft;
+    while(*ft != ITEM_FIELDS) {
+      if(! db_fget(item, *ft) )
+	return 1;
+      ft++;
+    }
+    ft = ftp;
+    fmt++;
+  }
+
+  while (*fmt) {
+    if(!strncmp(fmt, "%s", 2)) {
+      fprintf(out, "%s", safe_str(db_fget(item, *ft)));
+      ft++;
+      fmt+=2;
+    } else if (*ft == ITEM_FIELDS) {
+      fprintf(out, "%s", fmt);
+      return 0;
+    } else {
+      p = strchr(fmt, '%');
+      if(*p) {
+	q = strndup(fmt, (size_t)(p-fmt));
+	fprintf(out, "%s", q);
+	free(q);
+	fmt = p;
+      }
+      else {
+	fprintf(out, "%s", fmt);
+	return 0;
+      }
+    }
+  }
+
+  return 0;
+}
+
+// used to store the format string from --outformatstr when "custom" format is used
+// default value overriden from abook.c
+extern char custom_format[FORMAT_STRING_LEN];
+
+static int
+custom_export_database(FILE *out, struct db_enumerator e)
+{
+	char *format_string =
+	  (char *)malloc(FORMAT_STRING_LEN * sizeof(char*));
+
+	enum field_types *ft =
+	  (enum field_types *)malloc(FORMAT_STRING_MAX_FIELDS * sizeof(enum field_types *));
+
+	parse_custom_format(custom_format, format_string, ft);
+
+	db_enumerate_items(e) {
+	  if(custom_export_item(out, e.item, format_string, ft) == 0)
+	    fprintf(out, "\n");
+	}
+	return 0;
+}
+
+/*
+ * end of BSD calendar export filter
+ */
+