aboutsummaryrefslogblamecommitdiffstats
path: root/shell/e-config-upgrade.c
blob: 48f141bde8abe8d8ebf7c0ef67b1d1ec6666a112 (plain) (tree)
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
































                                                                           
                  










                               
             



                                      
                         












































































































































































































































































































































































































































































































                                                                                                                                              




























































































































                                                                                                                                                      
























                                                                                
                                             
                                
                                                                          







































































                                                                                                                                  





                                                                    




                                                                               
                                                           











































































































































































                                                                                                    
 





































































































































































                                                                                                                                                                    
                                                                     































































































































                                                                                                   




























































































































                                                                                            



                                                       





























































































                                                                                                                                                                 




                                                              






















                                                                                             

                                                                            

                                            
                                                    
                                                                          

                                                                              


                                                                                                   
                                          

















































































































                                                                                                                                     
                                                                    















                                                                             
                                                                                               




























































































                                                                                                                                                   
















                                                                      
   





                                                                      














                                    
                                           





























                                                                                               

                                               

















                                                                                                    
                                                                              













                                                                                         
















                                                                                                                 
                                                                   


















                                                                                         
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/* e-upgrade.c - upgrade previous config versions
 *
 * Copyright (C) 2003 Ximian, Inc.
 *
 * Authors: Michael Zucchi <notzed@ximian.com>
 *      Jeffery Stedfast <fejj@ximian.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include <stdio.h>
#include <errno.h>
#include <regex.h>
#include <string.h>
#include <ctype.h>

#include <glib.h>
#include <gconf/gconf.h>
#include <gconf/gconf-client.h>

#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/tree.h>

#include "e-config-upgrade.h"

#define d(x) 

/* output revision of configuration */
#define CONF_MAJOR (1)
#define CONF_MINOR (3)
#define CONF_REVISION (1)

/* major/minor/revision of existing config */
static unsigned int major = -1;
static unsigned int minor = -1;
static unsigned int revision = -1;

/* 1.0 details, if required */
static GHashTable *accounts_1_0 = NULL;
static GHashTable *accounts_name_1_0 = NULL;

/* where files are stored */
static const char *evolution_dir;

static char hexnib[256] = {
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1,
    -1,10,11,12,13,14,15,16,-1,-1,-1,-1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
    -1,10,11,12,13,14,15,16,-1,-1,-1,-1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
};

static char *hex_decode(const char *val)
{
    char *o, *res;
    const unsigned char *p = (const unsigned char *)val;
    
    o = res = g_malloc(strlen(val)/2 + 1);
    for (p=val;(p[0] && p[1]);p+=2)
        *o++ = (hexnib[p[0]] << 4) | hexnib[p[1]];
    *o = 0;

    return res;
}

static char *url_decode(const char *val)
{
    char *o, *res, c;
    const unsigned char *p = (const unsigned char *)val;
    
    o = res = g_malloc(strlen(val) + 1);
    while (*p) {
        c = *p++;
        if (c == '%'
            && hexnib[p[0]] != -1 && hexnib[p[1]] != -1) {
            *o++ = (hexnib[p[0]] << 4) | hexnib[p[1]];
            p+=2;
        } else
            *o++ = c;
    }
    *o = 0;

    return res;
}

/* so we dont need camel, just copy here */
static int
camel_file_util_decode_uint32 (FILE *in, guint32 *dest)
{
        guint32 value = 0;
    int v;

        /* until we get the last byte, keep decoding 7 bits at a time */
        while ( ((v = fgetc (in)) & 0x80) == 0 && v!=EOF) {
                value |= v;
                value <<= 7;
        }
    if (v == EOF) {
        *dest = value >> 7;
        return -1;
    }
    *dest = value | (v & 0x7f);

        return 0;
}

static int
camel_file_util_decode_string (FILE *in, char **str)
{
    guint32 len;
    register char *ret;

    if (camel_file_util_decode_uint32 (in, &len) == -1) {
        *str = NULL;
        return -1;
    }

    len--;
    if (len > 65536) {
        *str = NULL;
        return -1;
    }

    ret = g_malloc (len+1);
    if (len > 0 && fread (ret, len, 1, in) != 1) {
        g_free (ret);
        *str = NULL;
        return -1;
    }

    ret[len] = 0;
    *str = ret;
    return 0;
}

/* For 1.0.8 conversion */

/* as much info as we have on a given account */
struct _account_info {
    char *name;
    char *uri;
    char *base_uri;
    union {
        struct {
            /* for imap */
            char *namespace;
            char *namespace_full;
            guint32 capabilities;
            GHashTable *folders;
            char dir_sep;
        } imap;
    } u;
};

struct _imap_folder_info {
    char *folder;
    /* encoded?  decoded?  canonicalised? */
    char dir_sep;
};

static char *parse_lsub(const char *lsub, char *dir_sep)
{
    static int comp;
    static regex_t pat;
    regmatch_t match[3];
    char *m = "^\\* LSUB \\([^)]*\\) \"?([^\" ]+)\"? \"?(.*)\"?$";

    if (!comp) {
        if (regcomp(&pat, m, REG_EXTENDED|REG_ICASE) == -1) {
            g_warning("reg comp '%s' failed: %s", m, g_strerror(errno));
            return NULL;
        }
        comp = 1;
    }

    if (regexec(&pat, lsub, 3, match, 0) == 0) {
        if (match[1].rm_so != -1 && match[2].rm_so != -1) {
            if (dir_sep)
                *dir_sep = (match[1].rm_eo - match[1].rm_so == 1) ? lsub[match[1].rm_so] : 0;
            return g_strndup(lsub + match[2].rm_so, match[2].rm_eo - match[2].rm_so);
        }
    }

    return NULL;
}

static int read_imap_storeinfo(struct _account_info *si)
{
    FILE *storeinfo;
    guint32 tmp;
    char *buf, *folder, dir_sep, *path, *name, *p;
    struct _imap_folder_info *fi;

    si->u.imap.folders = g_hash_table_new(g_str_hash, g_str_equal);

    /* get details from uri first */
    name = strstr(si->uri, ";override_namespace");
    if (name) {
        name = strstr(si->uri, ";namespace=");
        if (name) {
            char *end;

            name += strlen(";namespace=");
            if (*name == '\"') {
                name++;
                end = strchr(name, '\"');
            } else {
                end = strchr(name, ';');
            }

            if (end) {
                /* try get the dir_sep from the namespace */
                si->u.imap.namespace = g_strndup(name, end-name);

                p = si->u.imap.namespace;
                while ((dir_sep = *p++)) {
                    if (dir_sep < '0'
                        || (dir_sep > '9' && dir_sep < 'A')
                        || (dir_sep > 'Z' && dir_sep < 'a')
                        || (dir_sep > 'z')) {
                        si->u.imap.dir_sep = dir_sep;
                        break;
                    }
                    p++;
                }
            }
        }
    }

    /* now load storeinfo if it exists */
    path = g_build_filename(evolution_dir, "mail/imap", si->base_uri+7, "storeinfo", NULL);
    storeinfo = fopen(path, "r");
    g_free(path);
    if (storeinfo == NULL) {
        g_warning("could not find imap store info '%s'", path);
        return -1;
    }

    /* ignore version */
    camel_file_util_decode_uint32(storeinfo, &tmp);
    camel_file_util_decode_uint32(storeinfo, &si->u.imap.capabilities);
    g_free(si->u.imap.namespace);
    camel_file_util_decode_string (storeinfo, &si->u.imap.namespace);
    camel_file_util_decode_uint32 (storeinfo, &tmp);
    si->u.imap.dir_sep = tmp;
    /* strip trailing dir_sep or / */
    if (si->u.imap.namespace
        && (si->u.imap.namespace[strlen(si->u.imap.namespace)-1] == si->u.imap.dir_sep
        || si->u.imap.namespace[strlen(si->u.imap.namespace)-1] == '/')) {
        si->u.imap.namespace[strlen(si->u.imap.namespace)-1] = 0;
    }

    d(printf("namespace '%s' dir_sep '%c'\n", si->u.imap.namespace, si->u.imap.dir_sep?si->u.imap.dir_sep:'?'));

    while (camel_file_util_decode_string (storeinfo, &buf) == 0) {
        folder = parse_lsub(buf, &dir_sep);
        if (folder) {
            fi = g_malloc0(sizeof(*fi));
            fi->folder = folder;
            fi->dir_sep = dir_sep;
#if d(!)0
            printf(" add folder '%s' ", folder);
            if (dir_sep)
                printf("'%c'\n", dir_sep);
            else
                printf("NIL\n");
#endif
            g_hash_table_insert(si->u.imap.folders, fi->folder, fi);
        } else {
            g_warning("Could not parse LIST result '%s'\n", buf);
        }
    }
    fclose(storeinfo);

    return 0;
}

static char *get_base_uri(const char *val)
{
    const char *tmp;

    tmp = strchr(val, ':');
    if (tmp) {
        tmp++;
        if (strncmp(tmp, "//", 2) == 0)
            tmp += 2;
        tmp = strchr(tmp, '/');
    }

    if (tmp)
        return g_strndup(val, tmp-val);
    else
        return g_strdup(val);
}

static char *upgrade_uri(const char *uri)
{
    char *out = NULL;

    /* upgrades camel uri's */

    if (major <=1 && minor < 2) {
        if (strncmp(uri, "imap:", 5) == 0) {
            char *base_uri, dir_sep, *folder, *p;
            struct _account_info *ai;

            /* add namespace, canonicalise dir_sep to / */
            base_uri = get_base_uri(uri);
            ai = g_hash_table_lookup(accounts_1_0, base_uri);

            if (ai == NULL) {
                g_free(base_uri);
                return NULL;
            }

            dir_sep = ai->u.imap.dir_sep;
            if (dir_sep == 0) {
                /* no dir_sep listed, try get it from the namespace, if set */
                if (ai->u.imap.namespace != NULL) {
                    p = ai->u.imap.namespace;
                    while ((dir_sep = *p++)) {
                        if (dir_sep < '0'
                            || (dir_sep > '9' && dir_sep < 'A')
                            || (dir_sep > 'Z' && dir_sep < 'a')
                            || (dir_sep > 'z')) {
                            break;
                        }
                        p++;
                    }
                }
                
                /* give up ... */
                if (dir_sep == 0) {
                    g_free(base_uri);
                    return NULL;
                }
            }

            folder = g_strdup(uri + strlen(base_uri)+1);

            /* Add the namespace before the mailbox name, unless the mailbox is INBOX */
            if (ai->u.imap.namespace && strcmp(folder, "INBOX") != 0)
                out = g_strdup_printf("%s/%s/%s", base_uri, ai->u.imap.namespace, folder);
            else
                out = g_strdup_printf("%s/%s", base_uri, folder);

            p = out;
            while (*p) {
                if (*p == dir_sep)
                    *p = '/';
                p++;
            }

            g_free(folder);
            g_free(base_uri);
        } else if (strncmp(uri, "exchange:", 9) == 0) {
            char *base_uri, *folder, *p;

            /*  exchange://user@host/exchange/ * -> exchange://user@host/personal/ * */
            /*  Any url encoding (%xx) in the folder name is also removed */
            base_uri = get_base_uri(uri);
            uri += strlen(base_uri) + 1;
            if (strncmp(uri, "exchange/", 9) == 0) {
                folder = url_decode(uri+9);
                p = strchr(folder, '/');
                out = g_strdup_printf("%s/personal%s", base_uri, p?p:"/");
                g_free(folder);
            }
        } else if (strncmp(uri, "exchanget:", 10) == 0) {
            /* these should be converted in the accounts table when it is loaded */
            g_warning("exchanget: uri not converted: '%s'", uri);
        }
    }

    return out;
}

static char *upgrade_evolution_uri(const char *uri)
{
    char *out = NULL;

    if (!strcmp (uri, "evolution:/local/Inbox")) {
        return g_strdup("default:mail");
    } else if (!strcmp (uri, "evolution:/local/Calendar")) {
        return g_strdup("default:calendar");
    } else if (!strcmp (uri, "evolution:/local/Contacts")) {
        return g_strdup("default:contacts");
    } else if (!strcmp (uri, "evolution:/local/Tasks")) {
        return g_strdup("default:tasks");
    } if (!strncmp(uri, "evolution:/", 11)) {
        char *account, *tmp, *folder, *p;
        struct _account_info *ai;

        d(printf("convert url '%s'\n", uri));
        tmp = strchr(uri+11, '/');
        if (tmp == NULL)
            return NULL;

        folder = *tmp?tmp+1:tmp;
        account = g_strndup(uri+11, tmp-uri-11);
        d(printf("  looking for account '%s'\n", account));
        ai = g_hash_table_lookup(accounts_name_1_0, account);
        if (ai && !strncmp(ai->base_uri, "imap:", 5)) {
            /* Add namespace to evolution url's of imap accounts, if the account uses a namespace */
            d(printf("found account ... '%s', folder = '%s'\n", ai->name, folder));
            
            if (ai->u.imap.namespace && strcmp(folder, "INBOX") != 0)
                out = g_strdup_printf("evolution:/%s/%s/%s", account, ai->u.imap.namespace, folder);
            else
                out = g_strdup_printf("evolution:/%s/%s", account, folder);
            
            if (ai->u.imap.dir_sep) {
                p = out + strlen("evolution://") + strlen(account);
                while (*p) {
                    if (*p == ai->u.imap.dir_sep)
                        *p = '/';
                    p++;
                }
            }
        } else if (ai && !strncmp(ai->base_uri, "exchange:", 9)) {
            /* add personal to exchange url's */
            folder = url_decode(folder);
            out = g_strdup_printf("evolution:/%s/personal/%s", account, folder);
            g_free(folder);
        }
        g_free(account);
    }

    return out;
}

static char *upgrade_type(const char *type)
{
    char *res = NULL;

    /*
      <item type="ldap-contacts ...>
      to
      <item type="contacts/ldap ...>
    */

    if (strcmp(type, "ldap-contacts") == 0)
        res = g_strdup("contacts/ldap");

    return res;
}

enum {
    CONVERT_CONTENT,
    CONVERT_ARG,
};

struct _convert {
    int type;
    char *tag;
    char *arg;
    char *(*convert)(const char *val);
} convert_table [] = {
    /* fix evolution uri's in shortcuts file */
    { CONVERT_CONTENT, "item", NULL, upgrade_evolution_uri },
    /* ldap item/type's converted from ldap-contacts to contacts/ldap */
    { CONVERT_ARG,     "item", "type", upgrade_type },
    /* fix folder uri's in filters/vfolders */
    { CONVERT_ARG,     "folder", "uri", upgrade_uri },
};

#define CONVERT_SIZEOF (sizeof(convert_table)/sizeof(convert_table[0]))

static int upgrade_xml_1_0_rec(xmlNodePtr node)
{
    int i;
    struct _convert *ct;
    int scan = TRUE;
    int work = FALSE;
    char *txt, *newtxt;

    for (i=0;i<CONVERT_SIZEOF;i++) {
        ct = &convert_table[i];
        if (!strcmp(node->name, ct->tag)) {
            switch(ct->type) {
            case CONVERT_CONTENT:
                txt = xmlNodeGetContent(node);
                newtxt = ct->convert(txt);
                d(printf("Upgrade content '%s': '%s' -> '%s'\n", ct->tag, txt, newtxt?newtxt:"unchanged"));
                xmlFree(txt);
                if (newtxt) {
                    xmlNodeSetContent(node, newtxt);
                    g_free(newtxt);
                    work = TRUE;
                }
                scan = FALSE;
                break;
            case CONVERT_ARG:
                txt = xmlGetProp(node, ct->arg);
                if (txt) {
                    newtxt = ct->convert(txt);
                    d(printf("Upgrade prop '%s' '%s': '%s' -> '%s'\n", ct->tag, ct->arg, txt, newtxt?newtxt:"unchanged"));
                    xmlFree(txt);
                    if (newtxt) {
                        xmlSetProp(node, ct->arg, newtxt);
                        g_free(newtxt);
                        work = TRUE;
                    }
                }
                break;
            }
        }
    }

    if (scan) {
        node = node->children;
        while (node) {
            work |= upgrade_xml_1_0_rec(node);
            node = node->next;
        }
    }

    return work;
}

/* ********************************************************************** */
/* XML 1 content encoding */

static int
is_xml1encoded(const char *txt)
{
    const unsigned char *p;
    int isxml1 = FALSE;
    int is8bit = FALSE;

    p = (const unsigned char *)txt;
    while (*p) {
        if (p[0] == '\\' && p[1] == 'U' && p[2] == '+'
            && isxdigit(p[3]) && isxdigit(p[4]) && isxdigit(p[5]) && isxdigit(p[6])
            && p[7] == '\\') {
            isxml1 = TRUE;
            p+=7;
        } else if (p[0] >= 0x80)
            is8bit = TRUE;
        p++;
    }

    /* check for invalid utf8 that needs cleaning */
    if (is8bit && (!isxml1))
        isxml1 = !g_utf8_validate(txt, -1, NULL);

    return isxml1;
}

static char *
decode_xml1(const char *txt)
{
    GString *out = g_string_new("");
    const unsigned char *p;
    char *res;

    /* convert:
                   \U+XXXX\ -> utf8
       8 bit characters -> utf8 (iso-8859-1) */

    p = (const unsigned char *)txt;
    while (*p) {
        if (p[0] > 0x80
            || (p[0] == '\\' && p[1] == 'U' && p[2] == '+'
            && isxdigit(p[3]) && isxdigit(p[4]) && isxdigit(p[5]) && isxdigit(p[6])
            && p[7] == '\\')) {
            char utf8[8];
            gunichar u;

            if (p[0] == '\\') {
                memcpy(utf8, p+3, 4);
                utf8[4] = 0;
                u = strtoul(utf8, NULL, 16);
                p+=7;
            } else
                u = p[0];
            utf8[g_unichar_to_utf8(u, utf8)] = 0;
            g_string_append(out, utf8);
        } else {
            g_string_append_c(out, *p);
        }
        p++;
    }

    res = out->str;
    g_string_free(out, FALSE);

    return res;
}

static int
upgrade_xml_1_2_rec(xmlNodePtr node)
{
    const char *value_tags[] = { "string", "address", "regex", "file", "command", NULL };
    const char *rule_tags[] = { "title", NULL };
    const struct {
        char *name;
        const char **tags;
    } tags[] = {
        { "value", value_tags },
        { "rule", rule_tags },
        { 0 },
    };
    int changed = 0;
    xmlNodePtr work;
    int i,j;
    char *txt, *tmp;

    /* upgrades the content of a node, if the node has a specific parent/node name */

    for (i=0;tags[i].name;i++) {
        if (!strcmp(node->name, tags[i].name)) {
            work = node->children;
            while (work) {
                for (j=0;tags[i].tags[j];j++) {
                    if (!strcmp(work->name, tags[i].tags[j])) {
                        txt = xmlNodeGetContent(work);
                        if (is_xml1encoded(txt)) {
                            tmp = decode_xml1(txt);
                            d(printf("upgrading xml node %s/%s '%s' -> '%s'\n", tags[i].name, tags[i].tags[j], txt, tmp));
                            xmlNodeSetContent(work, tmp);
                            changed = 1;
                            g_free(tmp);
                        }
                        xmlFree(txt);
                    }
                }
                work = work->next;
            }
            break;
        }
    }

    node = node->children;
    while (node) {
        changed |= upgrade_xml_1_2_rec(node);
        node = node->next;
    }

    return changed;
}

/* ********************************************************************** */

static int upgrade_xml_file(const char *filename, int (*upgrade_rec)(xmlNodePtr root))
{
    xmlDocPtr doc;
    char *savename;
    struct stat st;
    int res;

    /* FIXME: do something nicer with the errors */

    savename = alloca(strlen(filename)+64);
    sprintf(savename, "%s.save-%u.%u.%u", filename, major, minor, revision);
    if (stat(savename, &st) == 0) {
        fprintf(stderr, "xml file `%s' already upgraded\n", filename);
        return 0;
    }

    /* no file, no error */
    if (stat(filename, &st) == -1)
        return 0;

    doc = xmlParseFile (filename);
    if (!doc || !doc->xmlRootNode) {
        fprintf (stderr, "Failed to load %s\n", filename);
        return -1;
    }

    if (!upgrade_rec(doc->xmlRootNode)) {
        xmlFreeDoc(doc);
        printf("file %s contains nothing to upgrade\n", filename);
        return 0;
    }
    
    d(printf("backing up %s to %s\n", filename, savename));

    if (rename(filename, savename) == -1) {
        xmlFreeDoc(doc);
        fprintf(stderr, "could not rename '%s' to '%s': %s\n", filename, savename, strerror(errno));
        return -1;
    }

    res = xmlSaveFormatFile(filename, doc, 1);

    xmlFreeDoc(doc);

    return res;
}

/* ********************************************************************** */
/*  Tables for converting flat bonobo conf -> gconf xml blob          */
/* ********************************************************************** */

/* for remapping bonobo-conf account data into the new xml blob format */
/* These are used in build_xml, and order must match the lookup_table */
enum _map_t {
    MAP_END = 0,        /* end of line*/
    MAP_BOOL,       /* bool -> prop of name 'to' value true or false */
    MAP_LONG,       /* long -> prop of name 'to' value a long */
    MAP_STRING,     /* string -> prop of name 'to' */
    MAP_ENUM,       /* long/bool -> prop of name 'to', with the value indexed into the child map table's from field */
    MAP_CHILD,      /* a new child of name 'to' */
    MAP_MASK = 0x3f,
    MAP_URI_UPGRADE = 0x40, /* if from 1.0.x, upgrade any uri's present */
    MAP_CONTENT = 0x80, /* if set, create a new node of name 'to' instead of a property */
};

struct _map_table {
    char *from;
    char *to;
    int type;
    struct _map_table *child;
};

/* Mail/Accounts/ * */
struct _map_table cc_map[] = {
    { "account_always_cc_%i", "always", MAP_BOOL },
    { "account_always_cc_addrs_%i", "recipients", MAP_STRING|MAP_CONTENT },
    { NULL },
};

struct _map_table bcc_map[] = {
    { "account_always_cc_%i", "always", MAP_BOOL },
    { "account_always_bcc_addrs_%i", "recipients", MAP_STRING|MAP_CONTENT },
    { NULL },
};

struct _map_table pgp_map[] = {
    { "account_pgp_encrypt_to_self_%i", "encrypt-to-self", MAP_BOOL },
    { "account_pgp_always_trust_%i", "always-trust", MAP_BOOL },
    { "account_pgp_always_sign_%i", "always-sign", MAP_BOOL },
    { "account_pgp_no_imip_sign_%i", "no-imip-sign", MAP_BOOL },
    { "account_pgp_key_%i", "key-id", MAP_STRING|MAP_CONTENT },
    { NULL },
};

struct _map_table smime_map[] = {
    { "account_smime_encrypt_to_self_%i", "encrypt-to-self", MAP_BOOL },
    { "account_smime_always_sign_%i", "always-sign", MAP_BOOL },
    { "account_smime_key_%i", "key-id", MAP_STRING|MAP_CONTENT },
    { NULL },
};

struct _map_table identity_sig_map[] = {
    { "identity_autogenerated_signature_%i", "auto", MAP_BOOL },
    { "identity_def_signature_%i", "default", MAP_LONG },
    { NULL },
};

struct _map_table identity_map[] = {
    { "identity_name_%i", "name", MAP_STRING|MAP_CONTENT },
    { "identity_address_%i", "addr-spec", MAP_STRING|MAP_CONTENT },
    { "identity_reply_to_%i", "reply-to", MAP_STRING|MAP_CONTENT },
    { "identity_organization_%i", "organization", MAP_STRING|MAP_CONTENT },
    { NULL, "signature", MAP_CHILD, identity_sig_map },
    { NULL },
};

struct _map_table source_map[] = {
    { "source_save_passwd_%i", "save-passwd", MAP_BOOL },
    { "source_keep_on_server_%i", "keep-on-server", MAP_BOOL },
    { "source_auto_check_%i", "auto-check", MAP_BOOL },
    { "source_auto_check_time_%i", "auto-check-timeout", MAP_LONG },
    { "source_url_%i", "url", MAP_STRING|MAP_CONTENT },
    { NULL },
};

struct _map_table transport_map[] = {
    { "transport_save_passwd_%i", "save-passwd", MAP_BOOL },
    { "transport_url_%i", "url", MAP_STRING|MAP_CONTENT|MAP_URI_UPGRADE },
    { NULL },
};

struct _map_table account_map[] = {
    { "account_name_%i", "name", MAP_STRING },
    { "source_enabled_%i", "enabled", MAP_BOOL },
    { NULL, "identity", MAP_CHILD, identity_map },
    { NULL, "source", MAP_CHILD, source_map },
    { NULL, "transport", MAP_CHILD, transport_map },
    { "account_drafts_folder_uri_%i", "drafts-folder", MAP_STRING|MAP_CONTENT|MAP_URI_UPGRADE },
    { "account_sent_folder_uri_%i", "sent-folder", MAP_STRING|MAP_CONTENT|MAP_URI_UPGRADE },
    { NULL, "auto-cc", MAP_CHILD, cc_map },
    { NULL, "auto-bcc", MAP_CHILD, bcc_map },
    { NULL, "pgp", MAP_CHILD, pgp_map },
    { NULL, "smime", MAP_CHILD, smime_map },
    { NULL },
};

/* /Mail/Signatures/ * */
struct _map_table signature_format_map[] = {
    { "text/plain", },
    { "text/html", },
    { NULL }
};

struct _map_table signature_map[] = {
    { "name_%i", "name", MAP_STRING },
    { "html_%i", "format", MAP_ENUM, signature_format_map },
    { "filename_%i", "filename", MAP_STRING|MAP_CONTENT },
    { "script_%i", "script", MAP_STRING|MAP_CONTENT },
    { NULL },
};


static char *get_name(const char *in, int index)
{
    char c, *res;
    GString *out = g_string_new("");

    while ( (c = *in++) ) {
        if (c == '%') {
            c = *in++;
            switch(c) {
            case '%':
                g_string_append_c(out, '%');
                break;
            case 'i':
                g_string_append_printf(out, "%d", index);
                break;
            }
        } else {
            g_string_append_c(out, c);
        }
    }

    res = out->str;
    g_string_free(out, FALSE);

    return res;
}

static xmlNodePtr lookup_bconf_entry(xmlNodePtr source, const char *name)
{
    xmlNodePtr node = source->children;
    int found;
    char *val;

    while (node) {
        if (!strcmp(node->name, "entry")) {
            val = xmlGetProp(node, "name");
            found = val && strcmp(val, name) == 0;
            xmlFree(val);
            if (found)
                break;
        }
        node = node->next;
    }

    return node;
}

static char *lookup_bconf_value(xmlNodePtr source, const char *name)
{
    xmlNodePtr node = lookup_bconf_entry(source, name);

    if (node)
        return xmlGetProp(node, "value");
    else
        return NULL;
}

static xmlNodePtr lookup_bconf_path(xmlDocPtr doc, const char *path)
{
    xmlNodePtr root;
    char *val;
    int found;

    root = doc->children;
    if (strcmp(root->name, "bonobo-config") != 0) {
        g_warning("not bonobo-config xml file\n");
        return NULL;
    }

    root = root->children;
    while (root) {
        if (!strcmp(root->name, "section")) {
            val = xmlGetProp(root, "path");
            found = val && strcmp(val, path) == 0;
            xmlFree(val);
            if (found)
                break;
        }
        root = root->next;
    }

    return root;
}


static char *lookup_bool(xmlNodePtr source, const char *name, struct _map_table *map)
{
    char *val, *res;

    val = lookup_bconf_value(source, name);
    if (val) {
        res = g_strdup(val[0] == '1'?"true":"false");
        xmlFree(val);
    } else
        res = NULL;
    
    return res;
}

static char *lookup_long(xmlNodePtr source, const char *name, struct _map_table *map)
{
    char *val, *res;

    val = lookup_bconf_value(source, name);
    if (val) {
        res = g_strdup(val);
        xmlFree(val);
    } else
        res = NULL;
    
    return res;
}

static char *lookup_string(xmlNodePtr source, const char *name, struct _map_table *map)
{
    char *val, *res;

    val = lookup_bconf_value(source, name);
    if (val) {
        res = hex_decode(val);
        xmlFree(val);
    } else
        res = NULL;

    return res;
}

static char *lookup_enum(xmlNodePtr source, const char *name, struct _map_table *map)
{
    char *val;
    int index = 0, i;

    val = lookup_bconf_value(source, name);
    if (val) {
        index = atoi(val);
        xmlFree(val);
    }

    for (i=0;map->child[i].from;i++)
        if (i == index)
            return g_strdup(map->child[i].from);

    return NULL;
}

typedef char * (*lookup_func) (xmlNodePtr, const char *, struct _map_table *);

static void
build_xml(xmlNodePtr root, struct _map_table *map, int index, xmlNodePtr source)
{
    char *name, *value;
    xmlNodePtr node;
    lookup_func lookup_table[] = { lookup_bool, lookup_long, lookup_string, lookup_enum };

    while (map->type != MAP_END) {
        if ((map->type & MAP_MASK) == MAP_CHILD) {
            node = xmlNewChild(root, NULL, map->to, NULL);
            build_xml(node, map->child, index, source);
        } else {
            name = get_name(map->from, index);
            value = lookup_table[(map->type&MAP_MASK)-1](source, name, map);

            d(printf("key '%s=%s' -> ", name, value));

            if (map->type & MAP_URI_UPGRADE) {
                char *tmp = value;

                value = upgrade_uri(tmp);
                if (value)
                    g_free(tmp);
                else
                    value = tmp;
            }

            d(printf("'%s=%s'\n", map->to, value));

            if (map->type & MAP_CONTENT) {
                if (value && value[0])
                    xmlNewTextChild(root, NULL, map->to, value);
            } else {
                xmlSetProp(root, map->to, value);
            }
            g_free(value);
            g_free(name);
        }
        map++;
    }
}

static int convert_xml_blob(GConfClient *gconf, xmlDocPtr doc, struct _map_table *map, const char *path, const char *outpath, const char *name, const char *idparam)
{
    xmlNodePtr source;
    int count = 0, i;
    GSList *list, *l;
    char *val;

    source = lookup_bconf_path(doc, path);
    if (source) {
        list = NULL;
        val = lookup_bconf_value(source, "num");
        if (val) {
            count = atoi(val);
            xmlFree(val);
        }

        d(printf("Found %d blobs at %s\n", count, path));

        for (i = 0; i<count;i++) {
            xmlDocPtr docout;
            xmlChar *xmlbuf;
            int n;
            xmlNodePtr root;

            docout = xmlNewDoc ("1.0");
            root = xmlNewDocNode (docout, NULL, name, NULL);
            xmlDocSetRootElement (docout, root);

            /* This could be set with a MAP_UID type ... */
            if (idparam) {
                char buf[16];

                sprintf(buf, "%d", i);
                xmlSetProp(root, idparam, buf);
            }

            build_xml(root, map, i, source);
            
            xmlDocDumpMemory (docout, &xmlbuf, &n);
            xmlFreeDoc (docout);

            list = g_slist_append(list, xmlbuf);
        }

        gconf_client_set_list(gconf, outpath, GCONF_VALUE_STRING, list, NULL);
        while (list) {
            l = list->next;
            xmlFree(list->data);
            g_slist_free_1(list);
            list = l;
        }
    } else {
        g_warning("could not find '%s' in old config database, skipping", path);
    }

    return 0;
}

/* ********************************************************************** */
/*  Tables for bonobo conf -> gconf conversion                */
/* ********************************************************************** */

/* order important here, used to index a few tables below */
enum {
    BMAP_BOOL,
    BMAP_BOOLNOT,
    BMAP_INT,
    BMAP_STRING,
    BMAP_SIMPLESTRING,  /* a non-encoded string */
    BMAP_COLOUR,
    BMAP_FLOAT,     /* bloody floats, who uses floats ... idiots */
    BMAP_STRLIST,       /* strings separated to !<-->! -> gconf list */
    BMAP_ANYLIST,       /* corba sequence corba string -> gconf list */
    BMAP_MASK = 0x7f,
    BMAP_LIST = 0x80    /* from includes a %i field for the index of the key, to be converted to a list of type BMAP_* */
};

struct _gconf_map {
    char *from;
    char *to;
    int type;
};

/* ********************************************************************** */

static struct _gconf_map mail_accounts_map[] = {
    /* /Mail/Accounts - most entries are processed via the xml blob routine */
    /* This also works because the initial uid mapping is 1:1 with the list order */
    { "default_account", "mail/default_account", BMAP_SIMPLESTRING },
    { 0 },
};

static struct _gconf_map mail_display_map[] = {
    /* /Mail/Display */
    { "thread_list", "mail/display/thread_list", BMAP_BOOL },
    { "thread_subject", "mail/display/thread_subject", BMAP_BOOL },
    { "hide_deleted", "mail/display/show_deleted", BMAP_BOOLNOT },
    { "preview_pane", "mail/display/show_preview", BMAP_BOOL },
    { "paned_size", "mail/display/paned_size", BMAP_INT },
    { "seen_timeout", "mail/display/mark_seen_timeout", BMAP_INT },
    { "do_seen_timeout", "mail/display/mark_seen", BMAP_BOOL },
    { "http_images", "mail/display/load_http_images", BMAP_INT },
    { "citation_highlight", "mail/display/mark_citations", BMAP_BOOL },
    { "citation_color", "mail/display/citation_colour", BMAP_COLOUR },
    { "x_mailer_display_style", "mail/display/xmailer_mask", BMAP_INT },
    { 0 },
};

static struct _gconf_map mail_format_map[] = {
    /* /Mail/Format */
    { "message_display_style", "mail/display/message_style", BMAP_INT },
    { "send_html", "mail/composer/send_html", BMAP_BOOL },
    { "default_reply_style", "mail/format/reply_style", BMAP_INT },
    { "default_forward_style", "mail/format/forward_style", BMAP_INT },
    { "default_charset", "mail/composer/charset", BMAP_STRING },
    { "confirm_unwanted_html", "mail/prompts/unwanted_html", BMAP_BOOL },
    { 0 },
};

static struct _gconf_map mail_trash_map[] = {
    /* /Mail/Trash */
    { "empty_on_exit", "mail/trash/empty_on_exit", BMAP_BOOL },
    { 0 },
};

static struct _gconf_map mail_prompts_map[] = {
    /* /Mail/Prompts */
    { "confirm_expunge", "mail/prompts/expunge", BMAP_BOOL },
    { "empty_subject", "mail/prompts/empty_subject", BMAP_BOOL },
    { "only_bcc", "mail/prompts/only_bcc", BMAP_BOOL },
    { 0 }
};

static struct _gconf_map mail_filters_map[] = {
    /* /Mail/Filters */
    { "log", "mail/filters/log", BMAP_BOOL },
    { "log_path", "mail/filters/logfile", BMAP_STRING },
    { 0 }
};

static struct _gconf_map mail_notify_map[] = {
    /* /Mail/Notify */
    { "new_mail_notification", "mail/notify/type", BMAP_INT },
    { "new_mail_notification_sound_file", "mail/notify/sound", BMAP_STRING },
    { 0 }
};

static struct _gconf_map mail_filesel_map[] = {
    /* /Mail/Filesel */
    { "last_filesel_dir", "mail/save_dir", BMAP_STRING },
    { 0 }
};

static struct _gconf_map mail_composer_map[] = {
    /* /Mail/Composer */
    { "ViewFrom", "mail/composer/view/From", BMAP_BOOL },
    { "ViewReplyTo", "mail/composer/view/ReplyTo", BMAP_BOOL },
    { "ViewCC", "mail/composer/view/Cc", BMAP_BOOL },
    { "ViewBCC", "mail/composer/view/Bcc", BMAP_BOOL },
    { "ViewSubject", "mail/composer/view/Subject", BMAP_BOOL },
    { 0 },
};

/* ********************************************************************** */

static struct _gconf_map importer_elm_map[] = {
    /* /Importer/Elm */
    { "mail", "importer/elm/mail", BMAP_BOOL },
    { "mail-imported", "importer/elm/mail-imported", BMAP_BOOL },
    { 0 },
};

static struct _gconf_map importer_pine_map[] = {
    /* /Importer/Pine */
    { "mail", "importer/elm/mail", BMAP_BOOL },
    { "address", "importer/elm/address", BMAP_BOOL },
    { 0 },
};

static struct _gconf_map importer_netscape_map[] = {
    /* /Importer/Netscape */
    { "mail", "importer/netscape/mail", BMAP_BOOL },
    { "settings", "importer/netscape/settings", BMAP_BOOL },
    { "filters", "importer/netscape/filters", BMAP_BOOL },
    { 0 },
};

/* ********************************************************************** */

static struct _gconf_map myev_mail_map[] = {
    /* /My-Evolution/Mail */
    { "show_full_path", "summary/mail/show_full_paths", BMAP_BOOL },
    { 0 },
};

static struct _gconf_map myev_rdf_map[] = {
    /* /My-Evolution/RDF */
    { "rdf_urls", "summary/rdf/uris", BMAP_STRLIST },
    { "rdf_refresh_time", "summary/rdf/refresh_time", BMAP_INT },
    { "limit", "summary/rdf/max_items", BMAP_INT },
    { 0 },
};

static struct _gconf_map myev_weather_map[] = {
    /* /My-Evolution/Weather */
    { "stations", "summary/weather/stations", BMAP_STRLIST },
    { "units", "summary/weather/use_metric", BMAP_BOOL }, /* this is use_metric bool in 1.3? */
    { "weather_refresh_time", "summary/weather/refresh_time", BMAP_INT },
    { 0 },
};

static struct _gconf_map myev_schedule_map[] = {
    /* /My-Evolution/Shedule */
    { "show_tasks", "summary/tasks/show_all", BMAP_BOOL }, /* this is show_all bool in 1.3? */
    { 0 },
};

/* ********************************************************************** */

/* This grabs the defaults from the first view ... (?) */
static struct _gconf_map shell_views_map[] = {
    /* /Shell/Views/0 */
    { "Width", "shell/view_defaults/width", BMAP_INT },
    { "Height", "shell/view_defaults/height", BMAP_INT },
    { "CurrentShortcutsGroupNum", "shell/view_defaults/selected_shortcut_group", BMAP_INT },
    { "FolderBarShown", "shell/view_defaults/show_folder_bar", BMAP_BOOL },
    { "ShortcutBarShown", "shell/view_defaults/show_shortcut_bar", BMAP_BOOL },
    { "HPanedPosition", "shell/view_defaults/shortcut_bar/width", BMAP_INT },
    { "ViewPanedPosition", "shell/view_defaults/folder_bar/width", BMAP_INT },
    { "DisplayedURI", "shell/view_defaults/folder_path", BMAP_STRING },
    { 0 },
};

static struct _gconf_map offlinefolders_map[] = {
    /* /OfflineFolders */
    { "paths", "shell/offline/folder_paths", BMAP_ANYLIST },
    { 0 },
};

static struct _gconf_map defaultfolders_map[] = {
    /* /DefaultFolders */
    { "mail_path", "shell/default_folders/mail_path", BMAP_STRING },
    { "mail_uri", "shell/default_folders/mail_uri", BMAP_STRING },
    { "contacts_path", "shell/default_folders/contacts_path", BMAP_STRING },
    { "contacts_uri", "shell/default_folders/contacts_uri", BMAP_STRING },
    { "calendar_path", "shell/default_folders/calendar_path", BMAP_STRING },
    { "calendar_uri", "shell/default_folders/calendar_uri", BMAP_STRING },
    { "tasks_path", "shell/default_folders/tasks_path", BMAP_STRING },
    { "tasks_uri", "shell/default_folders/tasks_uri", BMAP_STRING },
    { 0 },
};

static struct _gconf_map shell_map[] = {
    /* /Shell */
    { "StartOffline", "shell/start_offline", BMAP_BOOL },
    { 0 },
};

/* ********************************************************************** */

static struct _gconf_map addressbook_map[] = {
    /* /Addressbook */
    { "select_names_uri", "addressbook/select_names/last_used_uri", BMAP_STRING },
    { 0 },
};

static struct _gconf_map addressbook_completion_map[] = {
    /* /Addressbook/Completion */
    { "uris", "addressbook/completion/uris", BMAP_STRING },
    { 0 },
};

/* ********************************************************************** */

static struct _gconf_map calendar_display_map[] = {
    /* /Calendar/Display */
    { "Timezone", "calendar/display/timezone", BMAP_STRING },
    { "Use24HourFormat", "calendar/display/use_24hour_format", BMAP_BOOL },
    { "WeekStartDay", "calendar/display/week_start_day", BMAP_INT },
    { "DayStartHour", "calendar/display/day_start_hour", BMAP_INT },
    { "DayStartMinute", "calendar/display/day_start_minute", BMAP_INT },
    { "DayEndHour", "calendar/display/day_end_hour", BMAP_INT },
    { "DayEndMinute", "calendar/display/day_end_minute", BMAP_INT },
    { "TimeDivisions", "calendar/display/time_divisions", BMAP_INT },
    { "View", "calendar/display/default_view", BMAP_INT },
    { "HPanePosition", "calendar/display/hpane_position", BMAP_FLOAT },
    { "VPanePosition", "calendar/display/vpane_position", BMAP_FLOAT },
    { "MonthHPanePosition", "calendar/display/month_hpane_position", BMAP_FLOAT },
    { "MonthVPanePosition", "calendar/display/month_vpane_position", BMAP_FLOAT },
    { "CompressWeekend", "calendar/display/compress_weekend", BMAP_BOOL },
    { "ShowEventEndTime", "calendar/display/show_event_end", BMAP_BOOL },
    { "WorkingDays", "calendar/display/working_days", BMAP_INT },
    { 0 },
};

static struct _gconf_map calendar_tasks_map[] = {
    /* /Calendar/Tasks */
    { "HideCompletedTasks", "calendar/tasks/hide_completed", BMAP_BOOL },
    { "HideCompletedTasksUnits", "calendar/tasks/hide_completed_units", BMAP_STRING },
    { "HideCompletedTasksValue", "calendar/tasks/hide_completed_value", BMAP_INT },
    { 0 },
};

static struct _gconf_map calendar_tasks_colours_map[] = {
    /* /Calendar/Tasks/Colors */
    { "TasksDueToday", "calendar/tasks/colors/due_today", BMAP_STRING },
    { "TasksOverDue", "calendar/tasks/colors/overdue", BMAP_STRING },
    { "TasksDueToday", "calendar/tasks/colors/due_today", BMAP_STRING },
    { 0 },
};

static struct _gconf_map calendar_other_map[] = {
    /* /Calendar/Other */
    { "ConfirmDelete", "calendar/prompts/confirm_delete", BMAP_BOOL },
    { "ConfirmExpunge", "calendar/prompts/confirm_expunge", BMAP_BOOL },
    { "UseDefaultReminder", "calendar/other/use_default_reminder", BMAP_BOOL },
    { "DefaultReminderInterval", "calendar/other/default_reminder_interval", BMAP_INT },
    { "DefaultReminderUnits", "calendar/other/default_reminder_units", BMAP_STRING },
    { 0 },
};

static struct _gconf_map calendar_datenavigator_map[] = {
    /* /Calendar/DateNavigator */
    { "ShowWeekNumbers", "calendar/date_navigator/show_week_numbers", BMAP_BOOL },
    { 0 },
};

static struct _gconf_map calendar_alarmnotify_map[] = {
    /* /Calendar/AlarmNotify */
    { "LastNotificationTime", "calendar/notify/last_notification_time", BMAP_INT },
    { "CalendarToLoad%i", "calendar/notify/calendars", BMAP_STRING|BMAP_LIST },
    { "BlessedProgram%i", "calendar/notify/programs", BMAP_STRING|BMAP_LIST },
    { 0 },
};

/* ********************************************************************** */

static struct {
    char *root;
    struct _gconf_map *map;
} gconf_remap_list[] = {
    { "/Mail/Accounts", mail_accounts_map },
    { "/Mail/Display", mail_display_map },
    { "/Mail/Format", mail_format_map },
    { "/Mail/Trash", mail_trash_map },
    { "/Mail/Prompts", mail_prompts_map },
    { "/Mail/Filters", mail_filters_map },
    { "/Mail/Notify", mail_notify_map },
    { "/Mail/Filesel", mail_filesel_map },
    { "/Mail/Composer", mail_composer_map },

    { "/Importer/Elm", importer_elm_map },
    { "/Importer/Pine", importer_pine_map },
    { "/Importer/Netscape", importer_netscape_map },

    { "My-Evolution/Mail", myev_mail_map },
    { "My-Evolution/RDF", myev_rdf_map },
    { "My-Evolution/Weather", myev_weather_map },
    { "My-Evolution/Schedule", myev_schedule_map },

    { "/Shell", shell_map },
    { "/Shell/Views/0", shell_views_map },
    { "/OfflineFolders", offlinefolders_map },
    { "/DefaultFolders", defaultfolders_map },

    { "/Addressbook", addressbook_map },
    { "/Addressbook/Completion", addressbook_completion_map },

    { "/Calendar/Display", calendar_display_map },
    { "/Calendar/Tasks", calendar_tasks_map },
    { "/Calendar/Tasks/Colors", calendar_tasks_colours_map },
    { "/Calendar/Other/Map", calendar_other_map },
    { "/Calendar/DateNavigator", calendar_datenavigator_map },
    { "/Calendar/AlarmNotify", calendar_alarmnotify_map },

    { 0 },
};

#define N_(x) x

struct {
    char *label;
    char *colour;
} label_default[5] = {
    { N_("Important"), "#ff0000" },  /* red */
    { N_("Work"),      "#ff8c00" },  /* orange */
    { N_("Personal"),  "#008b00" },  /* forest green */
    { N_("To Do"),     "#0000ff" },  /* blue */
    { N_("Later"),     "#8b008b" }   /* magenta */
};

/* remaps mail config from bconf to gconf */
static int import_bonobo_config(xmlDocPtr config_doc, GConfClient *gconf)
{
    xmlNodePtr source;
    int i, j, k;
    struct _gconf_map *map;
    char *path, *val, *tmp;
    GSList *list, *l;
    char buf[32];

    /* process all flat config */
    for (i=0;gconf_remap_list[i].root;i++) {
        d(printf("Path: %s\n", gconf_remap_list[i].root));
        source = lookup_bconf_path(config_doc, gconf_remap_list[i].root);
        if (source == NULL)
            continue;
        map = gconf_remap_list[i].map;
        for (j=0;map[j].from;j++) {
            if (map[j].type & BMAP_LIST) {
                /* collapse a multi-entry indexed field into a list */
                list = NULL;
                k = 0;
                do {
                    path = get_name(map[j].from, k);
                    val = lookup_bconf_value(source, path);
                    d(printf("finding path '%s' = '%s'\n", path, val));
                    g_free(path);
                    if (val) {
                        switch(map[j].type & BMAP_MASK) {
                        case BMAP_BOOL:
                        case BMAP_INT:
                            list = g_slist_append(list, GINT_TO_POINTER(atoi(val)));
                            break;
                        case BMAP_STRING:
                            d(printf(" -> '%s'\n", hex_decode(val)));
                            list = g_slist_append(list, hex_decode(val));
                            break;
                        }
                        xmlFree(val);
                        k++;
                    }
                } while (val);

                if (list) {
                    const int gconf_type[] = { GCONF_VALUE_BOOL, GCONF_VALUE_BOOL, GCONF_VALUE_INT, GCONF_VALUE_STRING, GCONF_VALUE_STRING };

                    path = g_strdup_printf("/apps/evolution/%s", map[j].to);
                    gconf_client_set_list(gconf, path, gconf_type[map[j].type & BMAP_MASK], list, NULL);
                    g_free(path);
                    if ((map[j].type & BMAP_MASK) == BMAP_STRING)
                        g_slist_foreach(list, (GFunc)g_free, NULL);
                    g_slist_free(list);
                }

                continue;
            } else if (map[j].type == BMAP_ANYLIST)
                val = NULL;
            else {
                val = lookup_bconf_value(source, map[j].from);
                if (val == NULL)
                    continue;
            }
            d(printf(" %s = '%s' -> %s [%d]\n",
                 map[j].from,
                 val == NULL ? "(null)" : val,
                 map[j].to,
                 map[j].type));
            path = g_strdup_printf("/apps/evolution/%s", map[j].to);
            switch(map[j].type) {
            case BMAP_BOOL:
                gconf_client_set_bool(gconf, path, atoi(val), NULL);
                break;
            case BMAP_BOOLNOT:
                gconf_client_set_bool(gconf, path, !atoi(val), NULL);
                break;
            case BMAP_INT:
                gconf_client_set_int(gconf, path, atoi(val), NULL);
                break;
            case BMAP_STRING:
                tmp = hex_decode(val);
                gconf_client_set_string(gconf, path, tmp, NULL);
                g_free(tmp);
                break;
            case BMAP_SIMPLESTRING:
                gconf_client_set_string(gconf, path, val, NULL);
                break;
            case BMAP_FLOAT:
                gconf_client_set_float(gconf, path, strtod(val, NULL), NULL);
                break;
            case BMAP_STRLIST:{
                char *v = hex_decode(val);
                char **t = g_strsplit (v, " !<-->! ", 8196);

                list = NULL;
                for (k=0;t[k];k++) {
                    list = g_slist_append(list, t[k]);
                    d(printf("  [%d] = '%s'\n", k, t[k]));
                }
                gconf_client_set_list(gconf, path, GCONF_VALUE_STRING, list, NULL);
                g_slist_free(list);
                g_strfreev(t);
                g_free(v);
                break;}
            case BMAP_ANYLIST:{
                xmlNodePtr node = source->children;
                list = NULL;

                /* find the entry node */
                while (node) {
                    if (!strcmp(node->name, "entry")) {
                        int found;

                        tmp = xmlGetProp(node, "name");
                        if (tmp) {
                            found = strcmp(tmp, map[j].from) == 0;
                            xmlFree(tmp);
                            if (found)
                                break;
                        }
                    }
                    node = node->next;
                }

                /* find the the any block */
                if (node) {
                    node = node->children;
                    while (node) {
                        if (strcmp(node->name, "any") == 0)
                            break;
                        node = node->next;
                    }
                }

                /* skip to the value inside it */
                if (node) {
                    node = node->children;
                    while (node) {
                        if (strcmp(node->name, "value") == 0)
                            break;
                        node = node->next;
                    }
                }

                if (node) {
                    node = node->children;
                    while (node) {
                        if (strcmp(node->name, "value") == 0)
                            list = g_slist_append(list, xmlNodeGetContent(node));
                        node = node->next;
                    }
                }

                /* & store */
                if (list) {
                    gconf_client_set_list(gconf, path, GCONF_VALUE_STRING, list, NULL);
                    while (list) {
                        l = list->next;
                        xmlFree(list->data);
                        g_slist_free_1(list);
                        list = l;
                    }
                }
                
                break;}
            case BMAP_COLOUR:
                sprintf(buf, "#%06x", atoi(val) & 0xffffff);
                gconf_client_set_string(gconf, path, buf, NULL);
                break;
            }
            /* FIXME: handle errors */
            g_free(path);
            xmlFree(val);
        }
    }

    /* Labels:
      label string + label colour as integer
       -> label string:# colour as hex */
    source = lookup_bconf_path(config_doc, "/Mail/Labels");
    if (source) {
        list = NULL;
        for (i=0;i<5;i++) {
            char labx[16], colx[16];
            char *lab, *col;

            sprintf(labx, "label_%d", i);
            sprintf(colx, "color_%d", i);
            lab = lookup_string(source, labx, NULL);
            col = lookup_bconf_value(source, colx);
            if (col) {
                sprintf(colx, "#%06x", atoi(col) & 0xffffff);
                xmlFree(col);
            } else
                strcpy(colx, label_default[i].colour);
            val = g_strdup_printf("%s:%s", lab?lab:label_default[i].label, colx);
            list = g_slist_append(list, val);
            g_free(lab);
        }

        gconf_client_set_list(gconf, "/apps/evolution/mail/labels", GCONF_VALUE_STRING, list, NULL);
        while (list) {
            l = list->next;
            g_free(list->data);
            g_slist_free_1(list);
            list = l;
        }
    } else {
        g_warning("could not find /Mail/Labels in old config database, skipping");
    }

    /* Accounts: The flat bonobo-config structure is remapped to a list of xml blobs.  Upgrades as necessary */
    convert_xml_blob(gconf, config_doc, account_map, "/Mail/Accounts", "/apps/evolution/mail/accounts", "account", "uid");
    /* Same for signatures */
    convert_xml_blob(gconf, config_doc, signature_map, "/Mail/Signatures", "/apps/evolution/mail/signatures", "signature", NULL);

    /* My-Evolution folder lists */
    source = lookup_bconf_path(config_doc, "My-Evolution/Mail");
    if (source) {
        char **t;

        list = NULL;
        l = NULL;

        val = lookup_string(source, "display_folders-1.2", NULL);
        /* FIXME: what needs upgrading here?  Anything? */
        if (val == NULL)
            val = lookup_string(source, "display_folders", NULL);

        if (val) {
            t = g_strsplit (val, " !<-->! ", 8196);
            for (i=0;t[i] && t[i+1];i+=2) {
                list = g_slist_append(list, t[i]);
                l = g_slist_append(l, t[i+1]);
                d(printf(" [%d] = euri: '%s', puri: '%s'\n", i, t[i], t[i+1]));
            }
            if (list) {
                gconf_client_set_list(gconf, "/apps/evolution/summary/mail/folder_evolution_uris", GCONF_VALUE_STRING, list, NULL);
                g_slist_free(list);
            }
            if (l) {
                gconf_client_set_list(gconf, "/apps/evolution/summary/mail/folder_physical_uris", GCONF_VALUE_STRING, l, NULL);
                g_slist_free(l);
            }
            g_strfreev(t);
        }
    }

    return 0;
}


static int load_accounts_1_0(xmlDocPtr doc)
{
    xmlNodePtr source;
    char *val, *tmp;
    int count = 0, i;
    char key[32];

    source = lookup_bconf_path(doc, "/Mail/Accounts");
    if (source == NULL)
        return 0;

    val = lookup_bconf_value(source, "num");
    if (val) {
        count = atoi(val);
        xmlFree(val);
    }

    /* load account upgrade info for each account */
    for (i=0;i<count;i++) {
        struct _account_info *ai;
        char *rawuri;

        sprintf(key, "source_url_%d", i);
        rawuri = lookup_bconf_value(source, key);
        if (rawuri == NULL)
            continue;
        ai = g_malloc0(sizeof(*ai));
        ai->uri = hex_decode(rawuri);
        ai->base_uri = get_base_uri(ai->uri);
        sprintf(key, "account_name_%d", i);
        ai->name = lookup_string(source, key, NULL);

        d(printf("load account '%s'\n", ai->uri));

        if (!strncmp(ai->uri, "imap:", 5)) {
            read_imap_storeinfo(ai);
        } else if (!strncmp(ai->uri, "exchange:", 9)) {
            xmlNodePtr node;

            d(printf(" upgrade exchange account\n"));
            /* small hack, poke the source_url into the transport_url for exchanget: transports
               - this will be picked up later in the conversion */
            sprintf(key, "transport_url_%d", i);
            node = lookup_bconf_entry(source, key);
            if (node
                && (val = xmlGetProp(node, "value"))) {
                tmp = hex_decode(val);
                xmlFree(val);
                if (strncmp(tmp, "exchanget:", 10) == 0)
                    xmlSetProp(node, "value", rawuri);
                g_free(tmp);
            } else {
                d(printf(" couldn't find transport uri?\n"));
            }
        }
        xmlFree(rawuri);

        g_hash_table_insert(accounts_1_0, ai->base_uri, ai);
        if (ai->name)
            g_hash_table_insert(accounts_name_1_0, ai->name, ai);
    }

    return 0;
}

/**
 * e_config_upgrade:
 * @edir: 
 * 
 * Upgrade evolution configuration from prior versions of evolution to
 * the current one.
 *
 * No work is performed if the configuration version is up to date.
 *
 * The tracked version is upgraded to the latest even if no
 * configuration upgrades are required for that version.
 *
 * Further information about how this is intended to work:
 *
 * There are 3 basic steps, numbered in the comments below.
 * 1. Determine the current config verison
 * 2. Upgrade to the current source version
 * 3. Save the version number, as defined by CONF_MAJOR, CONF_MINOR,
 *    CONF_REVISION.  These are all treated as integers, so 10 is
 *    greater than 9.
 *
 * 1 and 3 should not need changing.  After an upgrade to 1.3.x and
 * until the config system changes again (!), step one becomes
 * trivial.  Any changes to part 2 should be added to the end of the
 * section, or as required.  This allows for very fine-grained version
 * upgrades, including pre-release and patch-level changes to fix
 * config problems which may have lasted for a single version or
 * patch, in which case CONF_REVISION can be bumped.
 * 
 * At any time, the CONF_VERSION/MAJOR/REVISION can be increased to
 * match the source release, even if no new configuration changes will
 * be required from the previous version.  This should be done at each
 * release in case bugs in that configuration version are required to
 * be fixed at any time in the future.
 *
 * Return value: -1 on an error.
 **/
int
e_config_upgrade(const char *edir)
{
    xmlNodePtr source;
    xmlDocPtr config_doc = NULL;
    int i;
    char *val, *tmp;
    GConfClient *gconf;
    int res = -1;
    struct stat st;

    evolution_dir = edir;

    /* 1. determine existing version */
    gconf = gconf_client_get_default();
    val = gconf_client_get_string(gconf, "/apps/evolution/version", NULL);
    if (val) {
        sscanf(val, "%u.%u.%u", &major, &minor, &revision);
        g_free(val);
    } else {
        char *filename = g_build_filename(evolution_dir, "config.xmldb", NULL);

        if (lstat(filename, &st) == 0
            && S_ISREG(st.st_mode))
            config_doc = xmlParseFile (filename);
        g_free(filename);

        tmp = NULL;
        if ( config_doc
             && (source = lookup_bconf_path(config_doc, "/Shell"))
             && (tmp = lookup_bconf_value(source, "upgrade_from_1_0_to_1_2_performed"))
             && tmp[0] == '1' ) {
            major = 1;
            minor = 2;
            revision = 0;
        } else {
            major = 1;
            minor = 0;
            revision = 0;
        }
        if (tmp)
            xmlFree(tmp);
    }

    /* 2. Now perform any upgrade duties */

    d(printf("current config version is '%u.%u.%u'\n", major, minor, revision));

    /* For 1.0.x we need to load the accounts first, as data it initialises is used elsewhere */
    if (major <=1 && minor < 2) {
        char *xml_files[] = { "vfolders.xml", "filters.xml", "shortcuts.xml" };

        /* load in 1.0 info */
        if (config_doc) {
            accounts_1_0 = g_hash_table_new(g_str_hash, g_str_equal);
            accounts_name_1_0 = g_hash_table_new(g_str_hash, g_str_equal);
            load_accounts_1_0(config_doc);
        }

        /* upgrade xml uri fields */
        for (i=0;i<sizeof(xml_files)/sizeof(xml_files[0]);i++) {
            char *path;

            path = g_build_filename(evolution_dir, xml_files[i], NULL);
            if (upgrade_xml_file(path, upgrade_xml_1_0_rec) == -1)
                g_warning("Could not upgrade xml file %s", xml_files[i]);

            g_free(path);
        }
    }

    if (config_doc && major <=1 && minor < 3) {
        /* move bonobo config to gconf */
        if (import_bonobo_config(config_doc, gconf) == -1) {
            g_warning("Could not move config from bonobo-conf to gconf");
            goto error;
        }
    }

    if (major <=1 && minor <=3 && revision < 1) {
        /* check for xml 1 encoding from version 1.2 upgrade or from a previous previous 1.3.0 upgrade */
        char *xml_files[] = { "vfolders.xml", "filters.xml" };

        d(printf("Checking for xml1 format xml files\n"));

        for (i=0;i<sizeof(xml_files)/sizeof(xml_files[0]);i++) {
            char *path;

            path = g_build_filename(evolution_dir, xml_files[i], NULL);
            if (upgrade_xml_file(path, upgrade_xml_1_2_rec) == -1)
                g_warning("Could not upgrade xml file %s", xml_files[i]);

            g_free(path);
        }
    }

    /* 3. we're done, update our version info if its changed */
    if (major < CONF_MAJOR
        || minor < CONF_MINOR
        || revision < CONF_REVISION) {
        val = g_strdup_printf("%u.%u.%u", CONF_MAJOR, CONF_MINOR, CONF_REVISION);
        gconf_client_set_string(gconf, "/apps/evolution/version", val, NULL);
        /* TODO: should this be translatable? */
        g_message("Evolution configuration upgraded to version: %s", val);
        g_free(val);
        gconf_client_suggest_sync(gconf, NULL);
    }

    res = 0;

error:
    if (config_doc)
        xmlFreeDoc(config_doc);

    return res;
}