Mercurial > hg > idav / file revision

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2024 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "settings.h"

#include <cx/list.h>
#include <cx/array_list.h>
#include <cx/printf.h>
#include <libidav/utils.h>



#define SETTINGS_STATE_REPOLIST_SELECTED 1
#define SETTINGS_STATE_REPO_ENCRYPTION 20
#define SETTINGS_STATE_CREDENTIALS_SELECTED 30
#define SETTINGS_STATE_CREDENTIALS_LOCATION_SELECTED 31
#define SETTINGS_STATE_KEYS_SELECTED 40

#define SETTINGS_STATE_DISABLED 9999


static void repolist_activate(UiEvent *event, void *userdata) {
    UiListSelection *selection = event->eventdata;
    SettingsWindow *settings = event->window;
    settings_edit_repository(settings, selection->rows[0]);
}

static void repolist_selection(UiEvent *event, void *userdata) {
    UiListSelection *selection = event->eventdata;
    SettingsWindow *settings = event->window;
    if(selection->count > 0) {
        ui_set_group(event->obj->ctx, SETTINGS_STATE_REPOLIST_SELECTED);
        settings->selected_repo = selection->rows[0];
    } else {
        ui_unset_group(event->obj->ctx, SETTINGS_STATE_REPOLIST_SELECTED);
    }
}

static void repolist_edit(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    if(settings->selected_repo >= 0) {
        settings_edit_repository(settings, settings->selected_repo);
    }
}

static void repolist_add(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    settings->repo_new = TRUE;
    settings->selected_repo = -1;
    settings_clear_repository(settings);
    // switch to editing tab
    ui_set(settings->repo_tabview, 1);
}

static void repolist_remove(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    DavCfgRepository *repo = ui_list_get(settings->repos, settings->selected_repo);
    if(!repo) {
        fprintf(stderr, "Error: cannot get repository at index %d\n", settings->selected_repo);
        return;
    }
    dav_repository_remove_and_free(settings->config, repo);
    settings_update_repolist(settings);
    settings->selected_repo = -1;
    ui_unset_group(event->obj->ctx, SETTINGS_STATE_REPOLIST_SELECTED);
}

static void editrepo_go_back(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    settings_store_repository(settings);
    ui_set(settings->repo_tabview, 0);
}

static void credentials_add(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    if(settings_credentials_save(settings)) {
        return;
    }
    if(settings->credentials_list_needs_update) {
        settings->credentials_ignore_selectionevent = TRUE;
        ui_list_update(settings->credentials_users);
        settings_reload_repo_credentials(settings);
        settings->credentials_ignore_selectionevent = FALSE;
        settings->credentials_list_needs_update = FALSE;
    }
    settings_credentials_clear(settings);
    settings->credentials_new = TRUE;
    PwdStore *pwd = settings->pwdstore;
    if(!pwd->isdecrypted) {
        settings_credentials_decrypt(settings);
        return;
    }
    settings_credentials_select(settings, NULL);
}

static void addcred_onclick(UiEvent *event, void *userdata) {
    SettingsNewCredentialsDialog *wdata = event->window;
    if(event->intval == 4) {
        char *id = ui_get(wdata->id);
        char *user = ui_get(wdata->user);
        char *password = ui_get(wdata->password);
        int addlocation = ui_get(wdata->addlocation);
        
        if(strlen(id) == 0) {
            ui_set(wdata->message, "Missing identifier!");
            return;
        }
        if(strlen(user) == 0) {
            ui_set(wdata->message, "Missing user!");
            return;
        } 
        if(strlen(password) == 0) {
            ui_set(wdata->message, "Missing password!");
            return;
        }
        
        if(pwdstore_has_id(wdata->settings->pwdstore, id)) {
            ui_set(wdata->message, "Identifier already in use!");
            return;
        }
        
        CxList *locations = NULL;
        if(addlocation) {
            locations = cxLinkedListCreateSimple(CX_STORE_POINTERS);
            cxListAdd(locations, strdup(wdata->url));
        }
        pwdstore_put(wdata->settings->pwdstore, id, user, password);
        pwdstore_put_index(wdata->settings->pwdstore, strdup(id), locations);
        
        settings_reload_credentials(wdata->settings);
        settings_reload_repo_credentials(wdata->settings);
        
        CxList *list = wdata->settings->repo_credentials->data;
        ssize_t index = cxListFind(list, id);
        if(index >= 0) {
            ui_list_setselection(wdata->settings->repo_credentials, index);
        }
    }
    
    ui_close(event->obj);
}

// called by repo_edit
// create new credentials in dialog
static void credentials_new(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    
    UiObject *dialog = ui_dialog_window(event->obj,
            .modal = UI_ON,
            .title = "New Credentials",
            .show_closebutton = UI_OFF,
            .lbutton1 = "Cancel",
            .rbutton4 = "Add",
            .onclick = addcred_onclick);
    
    SettingsNewCredentialsDialog *wdata = ui_malloc(dialog->ctx, sizeof(SettingsNewCredentialsDialog));
    wdata->settings = settings;
    wdata->id = ui_string_new(dialog->ctx, NULL);
    wdata->user = ui_string_new(dialog->ctx, NULL);
    wdata->password = ui_string_new(dialog->ctx, NULL);
    wdata->addlocation = ui_int_new(dialog->ctx, NULL);
    wdata->message = ui_string_new(dialog->ctx, NULL);
    dialog->window = wdata;
    
    char *url = ui_get(settings->repo_url);
    if(strlen(url) > 0) {
        wdata->url = ui_strdup(dialog->ctx, url);
    } else {
        wdata->url = NULL;
    }
    
    ui_grid(dialog, .margin = 16, .columnspacing = 40, .rowspacing = 10) {
        ui_llabel(dialog, .label = "Identifier");
        ui_textfield(dialog, .value = wdata->id,  .hexpand = TRUE);
        ui_newline(dialog);
        
        ui_llabel(dialog, .label = "User");
        ui_textfield(dialog, .value = wdata->user, .hexpand = TRUE);
        ui_newline(dialog);
        
        ui_llabel(dialog, .label = "Password");
        ui_passwordfield(dialog, .value = wdata->password, .hexpand = TRUE);
        ui_newline(dialog);
        
        if(wdata->url) {
            cxmutstr msg = cx_asprintf("Add URL %s to Credential Locations", url);
            ui_checkbox(dialog, .label = msg.ptr, .value = wdata->addlocation, .colspan = 2);
            ui_newline(dialog);
            free(msg.ptr);
        }
        
        ui_llabel(dialog, .value = wdata->message, .colspan = 2);
    }
    
    ui_show(dialog);
}

static void credentials_remove(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    if(settings->credentials_selected_id) {
        pwdstore_remove_entry(settings->pwdstore, settings->credentials_selected_id);
        ui_list_remove(settings->credentials_users, settings->credentials_selected_index);
        ui_list_update(settings->credentials_users);
        settings_reload_repo_credentials(settings);
    }
}

static void credentials_onselect(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    if(settings->credentials_ignore_selectionevent) {
        return;
    }
    UiListSelection *sel = event->eventdata;
    if(settings_credentials_save(settings)) {
        return;
    }
    if(sel->count > 0) {
        const char *id = ui_list_get(settings->credentials_users, sel->rows[0]);
        settings->credentials_selected_index = sel->rows[0];
        settings_credentials_select(settings, id);
        if(settings->credentials_list_needs_update) {
            settings->credentials_ignore_selectionevent = TRUE;
            ui_list_update(settings->credentials_users);
            settings_reload_repo_credentials(settings);
            ui_list_setselection(settings->credentials_users, sel->rows[0]);
            settings->credentials_ignore_selectionevent = FALSE;
            settings->credentials_list_needs_update = FALSE;
        }
    } else {
        settings_credentials_clear(settings);
    }
}

static void c_add_location(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    if(event->intval == 1) {
        ui_list_append(settings->credentials_locations, ui_strdup(event->obj->ctx, event->eventdata));
        ui_list_update(settings->credentials_locations);
    }
}

static void credentials_location_add(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    ui_dialog(event->obj,
            .title = "Add Location",
            .content = "New Location URL",
            .input = TRUE,
            .result = c_add_location,
            .button1_label = "Add Location",
            .closebutton_label = "Cancel");
}

static void c_edit_location(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    if(event->intval == 1) {
        CxList *list = settings->credentials_locations->data;
        ssize_t i = cxListFind(list, userdata);
        if(i >= 0) {
            cxListRemove(list, i);
            cxListInsert(list, i, ui_strdup(event->obj->ctx, event->eventdata));
            ui_list_update(settings->credentials_locations);
        }
    }
}

static void credentials_location_edit(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    char *location = ui_list_get(settings->credentials_locations, settings->credentials_location_selected_index);
    if(!location) {
        return;
    }
    ui_dialog(event->obj,
            .title = "Edit Location",
            .content = "Location URL",
            .input_value = location,
            .input = TRUE,
            .result = c_edit_location,
            .resultdata = location,
            .button1_label = "Edit Location",
            .closebutton_label = "Cancel");
}

static void credentials_location_remove(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    if(settings->credentials_location_selected_index >= 0) {
        CxList *list = settings->credentials_locations->data;
        cxListRemove(list, settings->credentials_location_selected_index);
        ui_list_update(settings->credentials_locations);
    }
}

static void credentials_location_up(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    int index = settings->credentials_location_selected_index;
    if(index >= 1) {
        CxList *list = settings->credentials_locations->data;
        cxListSwap(list, index, index-1);
        ui_list_update(settings->credentials_locations);
        ui_list_setselection(settings->credentials_locations, index-1);
    }
}

static void credentials_location_down(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    int index = settings->credentials_location_selected_index;
    if(index >= 0 && index + 1 < ui_list_count(settings->credentials_locations)) {
        CxList *list = settings->credentials_locations->data;
        cxListSwap(list, index, index+1);
        ui_list_update(settings->credentials_locations);
        ui_list_setselection(settings->credentials_locations, index+1);
    }
}

static void credentials_location_onselect(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    UiListSelection *sel = event->eventdata;
    if(sel->count > 0) {
        settings->credentials_location_selected_index = sel->rows[0];
        ui_set_group(event->obj->ctx, SETTINGS_STATE_CREDENTIALS_LOCATION_SELECTED);
    } else {
        settings->credentials_location_selected_index = -1;
        ui_unset_group(event->obj->ctx, SETTINGS_STATE_CREDENTIALS_LOCATION_SELECTED);
    }
}

static void credentials_setmasterpw(UiEvent *event, void *userdata) {
    if(event->intval == 1) {
        SettingsWindow *settings = event->window;
        char *pw = event->eventdata;
        size_t pwlen = strlen(pw);
        if(pwlen > 0) {
            pwdstore_setpassword(settings->pwdstore, event->eventdata);
            memset(pw, 0, pwlen);
            if(!pwdstore_decrypt(settings->pwdstore)) {
                settings_credentials_select(settings, NULL);
            } else {
                ui_dialog(event->obj, .title = "Error", .content = "Cannot decrypt Secret Store", .closebutton_label = "OK");
            }
        }
    }
}

void settings_credentials_decrypt(SettingsWindow *settings) {
    ui_dialog(settings->obj,
            .title = "Secret Store",
            .content = "Master password",
            .password = TRUE,
            .result = credentials_setmasterpw,
            .button1_label = "Decrypt Secret Store",
            .closebutton_label = "Cancel");
}




#define ADDKEY_DIALOG_STATE_NO_IMPORT 10

static void addkey_onclick(UiEvent *event, void *userdata) {
    SettingsNewKeyDialog *wdata = event->window;
    if(event->intval == 4) {
        ui_set(wdata->message, "");
        
        // validate form
        char *name = ui_get(wdata->name);
        if(strlen(name) == 0) {
            ui_set(wdata->message, "A name must be specified!");
            return;
        }
        char *file = ui_get(wdata->file);
        if(strlen(file) == 0) {
            ui_set(wdata->message, "A file path must be specified!");
            return;
        }
        UiListSelection sel = ui_list_getselection(wdata->type);
        if(sel.count == 0) {
            ui_set(wdata->message, "No type selected!");
            return;
        }
        DavCfgKeyType type = sel.rows[0];
        
        // generate key file
        char *path = NULL;
        char *cfg_path = NULL;
        if(file[0] == '/') {
            path = file;
        } else {
            cfg_path = config_file_path(file);
            path = cfg_path;
        }
        FILE *f = fopen(path, "w");
        if(!f) {
            cxmutstr msg = cx_asprintf("Error: cannot write file '%s': %s", path, strerror(errno));
            ui_set(wdata->message, msg.ptr);
            free(msg.ptr);
            free(cfg_path);
            return;
        }
        free(cfg_path);
        
        unsigned char key[32];
        dav_rand_bytes(key, 32);
        
        size_t len;
        switch(type) {
            default:
            case DAV_KEY_TYPE_AES256: len = 32; break;
            case DAV_KEY_TYPE_AES128: len = 16; break;
        }
        size_t w = fwrite(key, 1, len, f);
        fclose(f);
        
        if(w != len) {
            cxmutstr msg = cx_asprintf("Could not write key data: %s", strerror(errno));
            ui_set(wdata->message, msg.ptr);
            free(msg.ptr);
            return;
        }
        
        // add key to config
        DavCfgKey *newkey = dav_key_new(wdata->settings->config);
        const CxAllocator *a = wdata->settings->config->mp->allocator;
        newkey->name.value = cx_strdup_a(a, cx_str(name));
        newkey->file.value = cx_strdup_a(a, cx_str(file));
        newkey->type = type;
        
        dav_config_add_key(wdata->settings->config, newkey);
        settings_reload_repo_keys(wdata->settings);
        settings_reload_keys(wdata->settings);
        
        if(wdata->add_to_repo && (wdata->settings->selected_repo >= 0 || wdata->settings->repo_new)) {
            CxList *repo_keys = wdata->settings->repo_keys->data;
            ssize_t index = cxListFind(repo_keys, name);
            if(index >= 0) {
                ui_list_setselection(wdata->settings->repo_keys, index);
            }
        }
    }
    
    ui_close(event->obj);
}

static void addkey_name_changed(UiEvent *event, void *userdata) {
    SettingsNewKeyDialog *wdata = event->window;
    char *name = ui_get(wdata->name);
    cxmutstr file = cx_asprintf("keys/%s", name);
    ui_set(wdata->file, file.ptr);
    free(file.ptr);
}

static void keys_add(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    
    UiObject *dialog = ui_dialog_window(event->obj,
            .modal = UI_ON,
            .title = "Add Key",
            .show_closebutton = UI_OFF,
            .lbutton1 = "Cancel",
            .rbutton4 = "Add",
            .default_button = 4,
            .onclick = addkey_onclick);
    SettingsNewKeyDialog *wdata = ui_malloc(dialog->ctx, sizeof(SettingsNewKeyDialog));
    wdata->settings = settings;
    wdata->name = ui_string_new(dialog->ctx, NULL);
    wdata->file = ui_string_new(dialog->ctx, NULL);
    wdata->import_path = ui_string_new(dialog->ctx, NULL);
    wdata->message = ui_string_new(dialog->ctx, NULL);
    wdata->secretstore = ui_int_new(dialog->ctx, NULL);
    wdata->type = ui_list_new(dialog->ctx, NULL);
    wdata->add_to_repo = userdata ? TRUE : FALSE;
    dialog->window = wdata;
    
    ui_list_append(wdata->type, "AES256");
    ui_list_append(wdata->type, "AES128");
    
    ui_grid(dialog, .margin = 16, .columnspacing = 40, .rowspacing = 10) {
        /*
        ui_hbox(dialog, .colspan = 2) {
            ui_button(dialog, .label = "Import Key...");
        }
        ui_newline(dialog);
        ui_llabel(dialog, .value = wdata->import_path);
        ui_newline(dialog);
        */
        
        ui_llabel(dialog, .label = "Name");
        ui_textfield(dialog, .value = wdata->name, .onchange = addkey_name_changed, .hexpand = TRUE);
        ui_newline(dialog);
        
        ui_llabel(dialog, .label = "File");
        ui_textfield(dialog, .value = wdata->file);
        ui_newline(dialog);
        
        ui_llabel(dialog, .label = "Type");
        ui_combobox(dialog, .list = wdata->type, .groups = UI_GROUPS(ADDKEY_DIALOG_STATE_NO_IMPORT));
        ui_newline(dialog);
        
        ui_llabel(dialog, .value = wdata->message, .colspan = 2);
    }
    
    ui_set_group(dialog->ctx, ADDKEY_DIALOG_STATE_NO_IMPORT);
    ui_list_setselection(wdata->type, 0);
    
    ui_show(dialog);
}

static void keys_remove(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    DavCfgKey *key = ui_list_get(settings->keys_list, settings->keys_selected_index);
    if(key) {
        dav_key_remove_and_free(settings->config, key);
        ui_list_remove(settings->keys_list, settings->keys_selected_index);
        ui_list_update(settings->keys_list);
        settings_reload_repo_keys(settings);
    }
}

static void keys_onselect(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    UiListSelection *sel = event->eventdata;
    if(sel->count > 0) {
        settings->keys_selected_index = sel->rows[0];
        DavCfgKey *key = ui_list_get(settings->keys_list, sel->rows[0]);
        if(key) {
            settings_edit_key(settings, key);
            ui_set_group(event->obj->ctx, SETTINGS_STATE_KEYS_SELECTED);
        }
    } else {
        settings->keys_selected_index = -1;
        settings_clear_key(settings);
        ui_unset_group(event->obj->ctx, SETTINGS_STATE_KEYS_SELECTED);
    }
}

static void list_str_destructor(void *data, void *ptr) {
    UiContext *ctx = data;
    char *s = ptr;
    ui_free(ctx, ptr);
}

static void secretstore_newmasterpw(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    if(event->intval == 1) {
        pwdstore_setpassword(settings->pwdstore, event->eventdata);
        set_pwdstore(settings->pwdstore);
        pwdstore_save(settings->pwdstore);
        settings->pwdstore = NULL;
    }
    ui_close(event->obj);
}

void settings_ok(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    // save any changed settings
    settings_store_repository(settings);
    settings_credentials_save(settings);
    
    set_config(settings->config);
    if(store_config()) {
        ui_dialog(event->obj, .title = "Error", .content = "Cannot store settings", .closebutton_label = "OK");
    }
    application_update_repolist(get_application());    settings->config = NULL;
    if(settings->credentials_modified) {
        if(settings->pwdstore->key) {
            set_pwdstore(settings->pwdstore);
            pwdstore_save(settings->pwdstore);
        } else {
            ui_dialog(event->obj,
                    .title = "Secret Store",
                    .content = "Master password",
                    .password = TRUE,
                    .result = secretstore_newmasterpw,
                    .button1_label = "Create Secret Store",
                    .closebutton_label = "Cancel",
                    .result = secretstore_newmasterpw);
            return;
        }
        settings->pwdstore = NULL;
    }
    ui_close(event->obj);
}

void settings_close(UiEvent *event, void *userdata) {
    SettingsWindow *settings = event->window;
    if(settings->config) {
        dav_config_free(settings->config);
    }
    if(settings->pwdstore) {
        pwdstore_free(settings->pwdstore);
    }
}

void settings_cancel(UiEvent *event, void *userdata) {
    ui_close(event->obj);
}

void settings_window_open() {
    DavConfig *config = load_config_file();
    if(!config) {
        return;
    }
    PwdStore *pwdstore = get_pwdstore();
    pwdstore = pwdstore ? pwdstore_clone(pwdstore) : pwdstore_new();
    
    UiObject *obj = ui_simple_window("Settings", NULL);
    ui_context_closefunc(obj->ctx, settings_close, NULL);
    SettingsWindow *wdata = ui_malloc(obj->ctx, sizeof(SettingsWindow));
    memset(wdata, 0, sizeof(SettingsWindow));
    wdata->config = config;
    wdata->pwdstore = pwdstore;
    obj->window = wdata;
    wdata->obj = obj;
    settings_init(obj, wdata);
    
    ui_tabview(obj) {
        ui_tab(obj, "General") {
            ui_grid(obj, .margin = 10) {
                ui_label(obj, .label = "TODO");
            }
        }
        
        ui_tab(obj, "Repositories") {
            
            ui_tabview(obj, .value = wdata->repo_tabview, .tabview = UI_TABVIEW_INVISIBLE) {
                ui_tab(obj, "list") {
                    ui_grid(obj, .margin = 16, .columnspacing = 10, .rowspacing = 10) {
                        ui_hbox(obj, .spacing = 4) {
                            ui_button(obj, .label = "Add", .onclick = repolist_add);
                            ui_button(obj, .label = "Edit", .onclick = repolist_edit, .groups = UI_GROUPS(SETTINGS_STATE_REPOLIST_SELECTED));
                            ui_button(obj, .label = "Remove", .onclick = repolist_remove, .groups = UI_GROUPS(SETTINGS_STATE_REPOLIST_SELECTED));
                        }
                        ui_newline(obj);
                        
                        UiModel* model = ui_model(obj->ctx, UI_STRING, "Name", UI_STRING, "URL", UI_STRING, "User", UI_STRING, "Encrypted", -1);
                        model->getvalue = (ui_getvaluefunc) settings_repolist_getvalue;
                        ui_table(obj,
                                .model = model,
                                .list = wdata->repos,
                                .multiselection = FALSE,
                                .onactivate = repolist_activate,
                                .onselection = repolist_selection,
                                .vexpand = TRUE, .hexpand = TRUE, .colspan = 3);
                    }
                }
                
                ui_tab(obj, "repo") {
                    ui_vbox(obj, .margin = 16, .spacing = 10) {
                        ui_hbox(obj, .fill = UI_OFF, .spacing = 4) {
                            ui_button(obj, .icon = UI_ICON_GO_BACK, .onclick = editrepo_go_back);
                            ui_label(obj, .label = "Repository List");
                        }
                        
                        ui_scrolledwindow(obj, .hexpand = TRUE, .vexpand = TRUE, .subcontainer = UI_CONTAINER_NO_SUB) {
                            ui_grid(obj, .margin = 10, .columnspacing = 10, .rowspacing = 10) {
                                ui_llabel(obj, .label = "Name");
                                ui_textfield(obj, .value = wdata->repo_name, .width = 15);
                                ui_newline(obj);
                                ui_llabel(obj, .label = "URL");
                                ui_textfield(obj, .value = wdata->repo_url, .hexpand = TRUE);
                                ui_newline(obj);
                                
                                ui_llabel(obj, .label = "Credentials", .style = UI_LABEL_STYLE_TITLE, .colspan = 2);
                                ui_newline(obj);
                                ui_hbox(obj, .spacing = 4, .colspan = 2) {
                                    ui_combobox(obj, .list = wdata->repo_credentials);
                                    ui_button(obj, .label = "New Credentials", .onclick = credentials_new);
                                }
                                ui_newline(obj);
                                ui_expander(obj, .spacing = 10, .colspan = 2, .label = "Unencrypted User/Password", .margin = 10) {
                                    ui_llabel(obj, .label = "Store the credentials unencrypted in the repository and not in the secret store", .style = UI_LABEL_STYLE_DIM);
                                    ui_grid(obj, .rowspacing = 10, .columnspacing = 10, .fill = UI_OFF) {
                                        ui_llabel(obj, .label = "User");
                                        ui_textfield(obj, .value = wdata->repo_user, .width = 15);
                                        ui_newline(obj);
                                        
                                        ui_llabel(obj, .label = "Password");
                                        ui_passwordfield(obj, .value = wdata->repo_password, .width = 15);
                                    }
                                }
                                ui_newline(obj);
                                
                                ui_llabel(obj, .label = "Encryption", .style = UI_LABEL_STYLE_TITLE, .colspan = 2);
                                ui_newline(obj);
                                
                                ui_checkbox(obj, .label = "Enable client-side encryption", .value = wdata->repo_encryption, .colspan = 2, .enable_group = SETTINGS_STATE_REPO_ENCRYPTION);
                                ui_newline(obj);
                                ui_llabel(obj, .label = "Default key");
                                ui_hbox(obj, .spacing = 4) {
                                    ui_combobox(obj, .list = wdata->repo_keys, .groups = UI_GROUPS(SETTINGS_STATE_REPO_ENCRYPTION));
                                    ui_button(obj, .label = "Generate Key", .onclick = keys_add, .onclickdata = "repo", .groups = UI_GROUPS(SETTINGS_STATE_REPO_ENCRYPTION));
                                }
                                ui_newline(obj);
                                
                                ui_llabel(obj, .label = "TLS", .style = UI_LABEL_STYLE_TITLE, .colspan = 2);
                                ui_newline(obj);
                                
                                ui_llabel(obj, .label = "Cert Path");
                                ui_hbox0(obj) {
                                    ui_textfield(obj, .value = wdata->repo_cacert, .width = 15);
                                }
                                ui_newline(obj);
                                
                                ui_llabel(obj, .label = "TLS Version");
                                ui_hbox0(obj) {
                                    ui_combobox(obj, .list = wdata->repo_tls_versions);
                                }
                                ui_newline(obj);
                                ui_checkbox(obj, .label = "Disable TLS verification", .value = wdata->repo_disable_verification, .colspan = 2);
                            }
                        }
                    }
                }
            }
            
            
        }
        
        ui_tab(obj, "Sync Directories") {
            ui_grid(obj, .margin = 10) {
                ui_label(obj, .label = "TODO");
            }
        }
        
        ui_tab(obj, "Credentials") {
            ui_hbox(obj, .margin = 16, .spacing = 30) {
                ui_vbox(obj, .fill = UI_OFF, .spacing = 4) {
                    ui_hbox(obj, .fill = UI_OFF, .spacing = 4) {
                        ui_button(obj, .label = "Add", .onclick = credentials_add);
                        ui_button(obj, .label = "Remove", .onclick = credentials_remove, .groups = UI_GROUPS(SETTINGS_STATE_CREDENTIALS_SELECTED));
                    }
                    ui_listview(obj, .list = wdata->credentials_users, .fill = UI_ON, .onselection = credentials_onselect);
                }
                
                ui_grid(obj, .columnspacing = 30, .rowspacing = 10) {
                    ui_llabel(obj, .label = "Identifier");
                    ui_textfield(obj, .value = wdata->credentials_id, .hexpand = TRUE, .groups = UI_GROUPS(SETTINGS_STATE_CREDENTIALS_SELECTED));
                    ui_newline(obj);
                    
                    ui_llabel(obj, .label = "User");
                    ui_textfield(obj, .value = wdata->credentials_user, .hexpand = TRUE, .groups = UI_GROUPS(SETTINGS_STATE_CREDENTIALS_SELECTED));
                    ui_newline(obj);
                    
                    ui_llabel(obj, .label = "Password");
                    ui_passwordfield(obj, .value = wdata->credentials_password, .hexpand = TRUE, .groups = UI_GROUPS(SETTINGS_STATE_CREDENTIALS_SELECTED));
                    ui_newline(obj);
                    
                    ui_label(obj, .label = " ");
                    ui_newline(obj);
                    
                    ui_llabel(obj, .style = UI_LABEL_STYLE_TITLE, .label = "Locations", .colspan = 2);
                    ui_newline(obj);
                    ui_llabel(obj, .style = UI_LABEL_STYLE_DIM, .label = "List of URLs for which these credentials should be used (optional)", .colspan = 2);
                    ui_newline(obj);
                    
                    ui_hbox(obj, .colspan = 2, .vexpand = TRUE, .hexpand = TRUE, .spacing = 10) {
                        ui_listview(obj, .list = wdata->credentials_locations, .onactivate = credentials_location_edit, .onselection = credentials_location_onselect, .colspan = 2, .fill = UI_ON, .groups = UI_GROUPS(SETTINGS_STATE_CREDENTIALS_SELECTED));
                        ui_vbox(obj, .fill = UI_OFF, .spacing = 4) {
                            ui_button(obj, .label = "Add", .onclick = credentials_location_add, .groups = UI_GROUPS(SETTINGS_STATE_CREDENTIALS_SELECTED));
                            ui_button(obj, .label = "Edit", .onclick = credentials_location_edit, .groups = UI_GROUPS(SETTINGS_STATE_CREDENTIALS_SELECTED, SETTINGS_STATE_CREDENTIALS_LOCATION_SELECTED));
                            ui_button(obj, .label = "Remove", .onclick = credentials_location_remove, .groups = UI_GROUPS(SETTINGS_STATE_CREDENTIALS_SELECTED, SETTINGS_STATE_CREDENTIALS_LOCATION_SELECTED));
                            ui_button(obj, .label = "Move Up", .onclick = credentials_location_up, .groups = UI_GROUPS(SETTINGS_STATE_CREDENTIALS_SELECTED, SETTINGS_STATE_CREDENTIALS_LOCATION_SELECTED));
                            ui_button(obj, .label = "Move Down", .onclick = credentials_location_down, .groups = UI_GROUPS(SETTINGS_STATE_CREDENTIALS_SELECTED, SETTINGS_STATE_CREDENTIALS_LOCATION_SELECTED));
                        }
                    }
                }
            }
        }
        
        ui_tab(obj, "Keys") {
            ui_hbox(obj, .margin = 16, .spacing = 30) {
                ui_vbox(obj, .fill = UI_OFF, .spacing = 4) {
                    ui_hbox(obj, .fill = UI_OFF, .spacing = 4) {
                        ui_button(obj, .label = "Add", .onclick = keys_add);
                        ui_button(obj, .label = "Remove", .onclick = keys_remove, .groups = UI_GROUPS(SETTINGS_STATE_KEYS_SELECTED));
                    }
                    ui_listview(obj, .list = wdata->keys_list, .fill = UI_ON, .onselection = keys_onselect, .getvalue = keylist_getvalue);
                }
                
                ui_grid(obj, .columnspacing = 30, .rowspacing = 10) {
                    ui_llabel(obj, .label = "Identifier");
                    ui_textfield(obj, .value = wdata->key_name, .groups = UI_GROUPS(SETTINGS_STATE_KEYS_SELECTED));
                    ui_newline(obj);
                    ui_llabel(obj, .label = "Type");
                    ui_textfield(obj, .value = wdata->key_type, .groups = UI_GROUPS(SETTINGS_STATE_DISABLED));
                    ui_newline(obj);
                    ui_llabel(obj, .label = "File");
                    ui_textfield(obj, .value = wdata->key_file, .groups = UI_GROUPS(SETTINGS_STATE_KEYS_SELECTED));
                }
            }
        }
        
        /*
        ui_tab(obj, "Properties") {
            ui_grid(obj, .margin = 10) {
                ui_label(obj, .label = "TODO");
            }
        }
        */
    }
        
    ui_hbox(obj, .fill = UI_OFF, .margin = 10) {
        ui_button(obj, .label = "Cancel", .onclick = settings_cancel);
        ui_label(obj, .fill = UI_ON);
        ui_button(obj, .label = "Save", .onclick = settings_ok);
    }
    
    
    ui_show(obj);
}

void settings_init(UiObject *obj, SettingsWindow *settings) {
    settings->repos = ui_list_new(obj->ctx, NULL);
    settings->repo_tabview = ui_int_new(obj->ctx, NULL);
    
    settings->repo_name = ui_string_new(obj->ctx, NULL);
    settings->repo_url = ui_string_new(obj->ctx, NULL);
    settings->repo_user = ui_string_new(obj->ctx, NULL);
    settings->repo_password = ui_string_new(obj->ctx, NULL);
    settings->repo_cacert = ui_string_new(obj->ctx, NULL);
    settings->repo_credentials = ui_list_new(obj->ctx, NULL);
    settings->repo_keys = ui_list_new(obj->ctx, NULL);
    settings->repo_tls_versions = ui_list_new(obj->ctx, NULL);
    settings->repo_encryption = ui_int_new(obj->ctx, NULL);
    settings->repo_disable_verification = ui_int_new(obj->ctx, NULL);
    CxList *repo_keys = settings->repo_keys->data;
    repo_keys->collection.cmpfunc = (cx_compare_func)strcmp;
     
    ui_list_append(settings->repo_tls_versions, "Default");
    ui_list_append(settings->repo_tls_versions, "TLSv1.3");
    ui_list_append(settings->repo_tls_versions, "TLSv1.2");
    ui_list_append(settings->repo_tls_versions, "TLSv1.1");
    ui_list_append(settings->repo_tls_versions, "TLSv1.0");
    
    settings->credentials_selected_index = -1;
    settings->credentials_users = ui_list_new(obj->ctx, NULL);
    settings->credentials_locations = ui_list_new(obj->ctx, NULL);
    settings->credentials_id = ui_string_new(obj->ctx, NULL);
    settings->credentials_user = ui_string_new(obj->ctx, NULL);
    settings->credentials_password = ui_string_new(obj->ctx, NULL);
    CxList *credentials_users = settings->credentials_users->data;
    CxList *credentials_locations = settings->credentials_locations->data;
    credentials_users->collection.advanced_destructor = list_str_destructor;
    credentials_users->collection.destructor_data = settings->obj->ctx;
    credentials_users->collection.cmpfunc = (cx_compare_func)strcmp;
    credentials_locations->collection.advanced_destructor = list_str_destructor;
    credentials_locations->collection.destructor_data = settings->obj->ctx;
    credentials_locations->collection.cmpfunc = (cx_compare_func)strcmp;
    
    settings->keys_list = ui_list_new(obj->ctx, NULL);
    settings->key_name = ui_string_new(obj->ctx, NULL);
    settings->key_type = ui_string_new(obj->ctx, NULL);
    settings->key_file = ui_string_new(obj->ctx, NULL);
    settings->keys_selected_index = -1;
    
    // load some list values, that can be reused
    settings_update_repolist(settings);
    settings_reload_repo_keys(settings);
    settings_reload_credentials(settings);
    settings_reload_repo_credentials(settings);
    settings_reload_keys(settings);
    
    settings->selected_repo = -1;
}

#define SETTINGS_SET_STRING(str, setting) if(setting.value.ptr) ui_set(str, setting.value.ptr);

/* ----------------------------- Repository ----------------------------- */

void settings_edit_repository(SettingsWindow *settings, int repo_index) {
    DavCfgRepository *repo = ui_list_get(settings->repos, repo_index);
    if(!repo) {
        fprintf(stderr, "Error: cannot get repository at index %d\n", repo_index);
        return;
    }
    settings->selected_repo = repo_index;
    
    // load plain string values
    SETTINGS_SET_STRING(settings->repo_name, repo->name);
    SETTINGS_SET_STRING(settings->repo_url, repo->url);
    SETTINGS_SET_STRING(settings->repo_cacert, repo->cert);
    SETTINGS_SET_STRING(settings->repo_user, repo->user);
    // load decrypted password
    if(repo->password.value.ptr) {
        char *decoded_pw = util_base64decode(repo->password.value.ptr);
        ui_set(settings->repo_password, decoded_pw);
        size_t decoded_pw_len = strlen(decoded_pw);
        memset(decoded_pw, 0, decoded_pw_len);
        free(decoded_pw);
    }
    
    // select credentials dropdown value
    CxList *cred = settings->repo_credentials->data;
    cred->collection.cmpfunc = (cx_compare_func)strcmp;
    ssize_t cred_index = repo->stored_user.value.ptr ? cxListFind(cred, repo->stored_user.value.ptr) : 0;
    if(cred_index > 0) {
        ui_list_setselection(settings->repo_credentials, cred_index);
    } else {
        ui_list_setselection(settings->repo_credentials, 0);
    }
    
    // load encryption value and default key value
    ui_set(settings->repo_encryption, repo->full_encryption.value);
    CxList *keys = settings->repo_keys->data;
    keys->collection.cmpfunc = (cx_compare_func)strcmp;
    ssize_t key_index = repo->default_key.value.ptr ? cxListFind(keys, repo->default_key.value.ptr) : 0;
    if(key_index > 0) {
        ui_list_setselection(settings->repo_keys, key_index);
    } else {
        ui_list_setselection(settings->repo_keys, 0);
    }
    
    // select tls version from dropdown menu
    CxList *tlsVersions = settings->repo_tls_versions->data;
    tlsVersions->collection.cmpfunc = (cx_compare_func)strcmp;
    const char *tls_str = dav_tlsversion2str(repo->ssl_version.value);
    if(!tls_str) tls_str = "";
    ssize_t tlsv_index = cxListFind(tlsVersions, tls_str);
    if(tlsv_index > 0) {
        ui_list_setselection(settings->repo_tls_versions, tlsv_index);
    } else {
        ui_list_setselection(settings->repo_tls_versions, 0);
    }
    
    if(!repo->verification.value) {
        ui_set(settings->repo_disable_verification, TRUE);
    }
    
    
    // switch to editing tab
    ui_set(settings->repo_tabview, 1);
}

/*
 * sets a config value
 * if new_value is null, the xml node is removed
 */
static void cfg_string_set_value_or_remove(DavConfig *config, CfgString *str, xmlNode *parent, cxstring new_value, const char *nodename) {
    if(new_value.length == 0) {
        new_value.ptr = NULL;
    }
    dav_cfg_string_set_value(config, str, parent, new_value, nodename);
    if(!new_value.ptr) {
        dav_cfg_string_remove(str);
    }
}

/*
 * return the selected list value, if it is not the default value at index 0
 */
static cxstring default_list_get_value(UiList *list) {
    cxstring ret = { NULL, 0 };
    UiListSelection sel = ui_list_getselection(list);
    if(sel.count > 0) {
        int index = sel.rows[0];
        if(index > 0) {
            ret = cx_str(ui_list_get(list, index));
        }        
        free(sel.rows);
    }
    return ret;
}

void settings_store_repository(SettingsWindow *settings) {
    DavConfig *config = settings->config;
    DavCfgRepository *repo;
    if(settings->repo_new) {
        settings->repo_new = FALSE;
        char *name = ui_get(settings->repo_name);
        if(strlen(name) == 0) {
            return;
        }
        repo = dav_repository_new(config);
        dav_config_add_repository(config, repo);
    } else if(settings->selected_repo >= 0) {
        repo = ui_list_get(settings->repos, settings->selected_repo);
        if(!repo) {
            fprintf(stderr, "Error: cannot get repository at index %d\n", settings->selected_repo);
            return;
        }
    } else {
        return;
    }
    
    // always store name/url nodes
    dav_cfg_string_set_value(config, &repo->name, repo->node, cx_str(ui_get(settings->repo_name)), "name");
    dav_cfg_string_set_value(config, &repo->url, repo->node, cx_str(ui_get(settings->repo_url)), "url");
    // store user of remove node, if no user is configured
    cfg_string_set_value_or_remove(config, &repo->user, repo->node, cx_str(ui_get(settings->repo_user)), "user");
    // store cert or remove node
    cfg_string_set_value_or_remove(config, &repo->cert, repo->node, cx_str(ui_get(settings->repo_cacert)), "cert");
    
    
    // store password or remove node, if no password is configured
    char *pw = ui_get(settings->repo_password);
    size_t pwlen = strlen(pw);
    if(pwlen > 0) {
        char *pwenc = util_base64encode(pw, pwlen);
        memset(pw, 0, pwlen);
        dav_cfg_string_set_value(config, &repo->password, repo->node, cx_str(pwenc), "password");
        free(pwenc);
    } else {
        // set password 0 NULL and remove password config node
        cfg_string_set_value_or_remove(config, &repo->password, repo->node, cx_strn(NULL, 0), "password");
    }
    
    // get the selected credentials and set "stored-user"
    // remove node if not needed
    cxstring stored_user = default_list_get_value(settings->repo_credentials);
    cfg_string_set_value_or_remove(config, &repo->stored_user, repo->node, stored_user, "stored-user");
    
    // adjust full-encryption node if necessary
    int encryption = ui_get(settings->repo_encryption);
    if(encryption || repo->full_encryption.node) {
        dav_cfg_bool_set_value(config, &repo->full_encryption, repo->node, encryption, "full-encryption");
    }
    
    // set default-key
    cxstring key = default_list_get_value(settings->repo_keys);
    cfg_string_set_value_or_remove(config, &repo->default_key, repo->node, key, "default-key");
    
    // if disable_verification is enabled, set repo verification to false
    // otherwise remove the node, because verification is enabled by default
    int disable_verification = ui_get(settings->repo_disable_verification);
    if(disable_verification) {
        dav_cfg_bool_set_value(config, &repo->verification, repo->node, !disable_verification, "verification");
    } else {
        dav_cfg_bool_remove(&repo->verification);
    }
    
    // set tls version if configured
    cxstring tlsversion_str = default_list_get_value(settings->repo_tls_versions);
    int tlsversion = dav_str2ssl_version(tlsversion_str.ptr);
    if(tlsversion >= 0) {
        dav_cfg_int_set_value(config, &repo->ssl_version, repo->node, tlsversion, "ssl-version");
    } else {
        dav_cfg_int_remove(&repo->ssl_version);
    }
    
    settings_update_repolist(settings);
    settings->selected_repo = -1;
}

void settings_clear_repository(SettingsWindow *settings) {
    ui_set(settings->repo_name, "");
    ui_set(settings->repo_url, "");
    ui_set(settings->repo_user, "");
    ui_set(settings->repo_password, "");
    ui_set(settings->repo_cacert, "");
    ui_list_setselection(settings->repo_credentials, 0);
    ui_list_setselection(settings->repo_keys, 0);
    ui_list_setselection(settings->repo_tls_versions, 0);
    ui_set(settings->repo_encryption, 0);
    ui_set(settings->repo_disable_verification, 0);
}

void settings_update_repolist(SettingsWindow *settings) {
    DavConfig *config = settings->config;

    ui_list_clear(settings->repos);

    for (DavCfgRepository *repo = config->repositories; repo; repo = repo->next) {
        ui_list_append(settings->repos, repo);
    }
    
    if(settings->repos->update) {
        ui_list_update(settings->repos);
    }
}

void* settings_repolist_getvalue(DavCfgRepository *repo, int col) {
    switch(col) {
        case 0: {
            return repo->name.value.ptr;
        }
        case 1: {
            return repo->url.value.ptr;
        }
        case 2: {
            return repo->user.value.ptr;
        }
        case 3: {
            return repo->full_encryption.value ? "yes" : "no";
        }
    }
    return NULL;
}

void settings_reload_repo_keys(SettingsWindow *settings) {
    DavConfig *config = settings->config;
    DavCfgKey *key = config->keys; 
    ui_list_clear(settings->repo_keys);
    ui_list_append(settings->repo_keys, "-");
    while(key) {
        if(key->name.value.ptr) {
            ui_list_append(settings->repo_keys, key->name.value.ptr);
        }
        key = key->next;
    }
    ui_list_update(settings->repo_keys);
}

void settings_reload_keys(SettingsWindow *settings) {
    DavConfig *config = settings->config;
    DavCfgKey *key = config->keys; 
    ui_list_clear(settings->keys_list);
    while(key) {
        if(key->name.value.ptr) {
            ui_list_append(settings->keys_list, key);
        }
        key = key->next;
    }
    ui_list_update(settings->keys_list);
}

const char* dav_tlsversion2str(int value) {
    if(value == CURL_SSLVERSION_TLSv1) {
        return "TLSv1";
    } else if(value == CURL_SSLVERSION_SSLv2) {
        return "SSLv2";
    } else if(value == CURL_SSLVERSION_SSLv3) {
        return "SSLv3";
    }
#if LIBCURL_VERSION_MAJOR * 1000 + LIBCURL_VERSION_MINOR >= 7034
    else if(value == CURL_SSLVERSION_TLSv1_0) {
        return "TLSv1.0";
    } else if(value == CURL_SSLVERSION_TLSv1_1) {
        return "TLSv1.1";
    } else if(value == CURL_SSLVERSION_TLSv1_2) {
        return "TLSv1.2";
    }
#endif
#if LIBCURL_VERSION_MAJOR * 1000 + LIBCURL_VERSION_MINOR >= 7052
    else if(value == CURL_SSLVERSION_TLSv1_3) {
        return "TLSv1.3";
    }
#endif
    return NULL;
}


/* ----------------------------- Credentials ----------------------------- */

void settings_reload_credentials(SettingsWindow *settings) {
    PwdStore *pwd = settings->pwdstore;
    
    ui_list_clear(settings->credentials_users);
    
    CxIterator i = cxListIterator(pwd->noloc);
    cx_foreach(PwdIndexEntry*, entry, i) {
        char *id = ui_strdup(settings->obj->ctx, entry->id);
        ui_list_append(settings->credentials_users, id);
    }
    i = cxListIterator(pwd->locations);
    cx_foreach(PwdIndexEntry*, entry, i) {
        char *id = ui_strdup(settings->obj->ctx, entry->id);
        ui_list_append(settings->credentials_users, id);
    }
    
    ui_list_update(settings->credentials_users);
}

void settings_reload_repo_credentials(SettingsWindow *settings) {
    PwdStore *pwd = settings->pwdstore;
    
    ui_list_clear(settings->repo_credentials);
    
    // repo_credentials needs an entry for selecting no credentials
    ui_list_append(settings->repo_credentials, "-");
    
    CxIterator i = cxListIterator(pwd->noloc);
    cx_foreach(PwdIndexEntry*, entry, i) {
        char *id = ui_strdup(settings->obj->ctx, entry->id);
        ui_list_append(settings->repo_credentials, id);
    }
    i = cxListIterator(pwd->locations);
    cx_foreach(PwdIndexEntry*, entry, i) {
        char *id = ui_strdup(settings->obj->ctx, entry->id);
        ui_list_append(settings->repo_credentials, id);
    }
    
    ui_list_update(settings->repo_credentials);
}


void settings_credentials_select(SettingsWindow *settings, const char *id) {
    if(!id && !settings->credentials_selected_id && !settings->credentials_new) {
        fprintf(stderr, "Error: no credentials id selected\n");
        return;
    }
    
    PwdStore *pwd = settings->pwdstore;
    
    if(id) {
        ui_free(settings->obj->ctx, settings->credentials_selected_id);
        settings->credentials_selected_id = ui_strdup(settings->obj->ctx, id);
    }
    
    if(!pwd->isdecrypted) {
        settings_credentials_decrypt(settings);
        return;
    }
    
    if(settings->credentials_new) {
        ui_free(settings->obj->ctx, settings->credentials_selected_id);
        settings->credentials_selected_id = NULL;
        settings->credentials_selected_index = ui_list_count(settings->credentials_users);
        ui_list_append(settings->credentials_users, ui_strdup(settings->obj->ctx, "new"));
        settings->credentials_ignore_selectionevent = TRUE;
        ui_list_update(settings->credentials_users);
        ui_list_setselection(settings->credentials_users, settings->credentials_selected_index);
        settings->credentials_ignore_selectionevent = FALSE;
        
        ui_set(settings->credentials_id, "new");
        ui_set(settings->credentials_user, "");
        ui_set(settings->credentials_password, "");
        ui_list_clear(settings->credentials_locations);
        ui_list_update(settings->credentials_locations);
    } else {
        PwdEntry *entry = cxMapGet(pwd->ids, settings->credentials_selected_id);
        PwdIndexEntry *index = cxMapGet(pwd->index, settings->credentials_selected_id);
        if(!entry) {
            fprintf(stderr, "Error: cannot get pwd entry %s\n", settings->credentials_selected_id);
            return;
        }
        if(!index) {
            fprintf(stderr, "Error: missing PwdIndexEntry. PwdStore may be broken.\n");
            return;
        }

        ui_set(settings->credentials_id, entry->id);
        ui_set(settings->credentials_user, entry->user);
        ui_set(settings->credentials_password, entry->password);

        ui_list_clear(settings->credentials_locations);
        if(index->locations) {
            CxIterator i = cxListIterator(index->locations);
            cx_foreach(char *, loc, i) {
                ui_list_append(settings->credentials_locations, ui_strdup(settings->obj->ctx, loc));
            }
        }
    }
    
    ui_list_update(settings->credentials_locations);
    
    ui_set_group(settings->obj->ctx, SETTINGS_STATE_CREDENTIALS_SELECTED);
}

void settings_credentials_clear(SettingsWindow *settings) {
    ui_free(settings->obj->ctx, settings->credentials_selected_id);
    settings->credentials_selected_id = NULL;
    settings->credentials_new = FALSE;
    
    ui_set(settings->credentials_id, "");
    ui_set(settings->credentials_user, "");
    ui_set(settings->credentials_password, "");
    ui_list_clear(settings->credentials_locations);
    ui_list_update(settings->credentials_locations);
    
    ui_unset_group(settings->obj->ctx, SETTINGS_STATE_CREDENTIALS_SELECTED);
}

int settings_credentials_save(SettingsWindow *settings) {
    if(settings->credentials_selected_index == -1) {
        return 0;
    }
    
    // check if the credentials list contains an element with the same id
    // if an index is found, it must match the selected index, otherwise
    // we have a duplicate identifier
    char *newid = ui_get(settings->credentials_id);
    if(strlen(newid) == 0) {
        return 0; // TODO: check if other fields are set
    }
    
    ssize_t index = cxListFind(settings->credentials_users->data, newid);
    if(index >=0 && index != settings->credentials_selected_index) {
        cxmutstr s = cx_asprintf("Identifier %s already in use", newid);
        ui_dialog(settings->obj, .title = "Error", .content = s.ptr, .closebutton_label = "OK");
        free(s.ptr);
        return 1;
    }
    
    char *user = ui_get(settings->credentials_user);
    char *password = ui_get(settings->credentials_password);
    CxList *ui_locations = settings->credentials_locations->data;
    size_t numlocations = cxListSize(ui_locations);
    CxList *locations = NULL;
    if(numlocations > 0) {
        locations = cxArrayListCreateSimple(CX_STORE_POINTERS, numlocations);
        CxIterator i = cxListIterator(ui_locations);
        cx_foreach(char*, loc, i) {
            cxListAdd(locations, strdup(loc));
        }
    }
    
    // if the user id changed, mark the list as changed to update it later
    settings->credentials_list_needs_update = settings->credentials_new || strcmp(newid, settings->credentials_selected_id);
    if(settings->credentials_new || strcmp(newid, settings->credentials_selected_id ? settings->credentials_selected_id : "")) {
        settings->credentials_list_needs_update = TRUE;
        cxListRemove(settings->credentials_users->data, settings->credentials_selected_index);
        cxListInsert(settings->credentials_users->data, settings->credentials_selected_index, ui_strdup(settings->obj->ctx, newid));
    }
    
    // if the pwdstore already contains this id, remove it first
    if(settings->credentials_selected_id) {
        pwdstore_remove_entry(settings->pwdstore, settings->credentials_selected_id);
    }
    
    pwdstore_put(settings->pwdstore, newid, user, password);
    pwdstore_put_index(settings->pwdstore, strdup(newid), locations);
    settings->credentials_modified = TRUE;
    settings->credentials_new = FALSE;
    
    return 0;
}

void *keylist_getvalue(void *data, int col) {
    DavCfgKey *key = data;
    return key->name.value.ptr;
}

void settings_edit_key(SettingsWindow *settings, DavCfgKey *key) {
    if(key->name.value.ptr) {
        ui_set(settings->key_name, key->name.value.ptr);
    }
    const char *key_type;
    switch(key->type) {
        default: key_type = ""; break;
        case DAV_KEY_TYPE_AES256: {
            key_type = "AES256";
            break;
        }
        case DAV_KEY_TYPE_AES128: {
            key_type = "AES128";
            break;
        }
        case DAV_KEY_TYPE_UNKNOWN: {
            key_type = "unknown";
            break;
        }
    }
    ui_set(settings->key_type, key_type);
    
    if(key->file.value.ptr) {
        ui_set(settings->key_file, key->file.value.ptr);
    }
}

void settings_clear_key(SettingsWindow *settings) {
    ui_set(settings->key_name, "");
    ui_set(settings->key_type, "");
    ui_set(settings->key_file, "");
}