plugins/imap-acl/imap-acl-plugin.c

	imap-acl-plugin.c revision ac0fed903142d28ae3a1d5d00d2097fdf161b138
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen/* Copyright (c) 2008-2010 Dovecot authors, see the included COPYING file */
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen#include "imap-common.h"
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen#include "str.h"
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen#include "imap-quote.h"
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen#include "imap-resp-code.h"
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen#include "imap-commands.h"
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen#include "mail-storage.h"
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen#include "mail-namespace.h"
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#include "acl-api.h"
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#include "acl-storage.h"
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#include "acl-plugin.h"
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen#include "imap-acl-plugin.h"
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#include <stdlib.h>
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#define ERROR_NOT_ADMIN "["IMAP_RESP_CODE_NOPERM"] " \
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    "You lack administrator privileges on this mailbox."
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#define ACL_MAILBOX_FLAGS \
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    (MAILBOX_FLAG_READONLY | MAILBOX_FLAG_KEEP_RECENT)
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#define IMAP_ACL_ANYONE "anyone"
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#define IMAP_ACL_AUTHENTICATED "authenticated"
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#define IMAP_ACL_OWNER "owner"
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#define IMAP_ACL_GROUP_PREFIX "$"
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#define IMAP_ACL_GROUP_OVERRIDE_PREFIX "!$"
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen#define IMAP_ACL_GLOBAL_PREFIX "#"
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainenstruct imap_acl_letter_map {
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    char letter;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    const char *name;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen};
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainenstatic const struct imap_acl_letter_map imap_acl_letter_map[] = {
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 'l', MAIL_ACL_LOOKUP },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 'r', MAIL_ACL_READ },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 'w', MAIL_ACL_WRITE },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 's', MAIL_ACL_WRITE_SEEN },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 't', MAIL_ACL_WRITE_DELETED },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 'i', MAIL_ACL_INSERT },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 'p', MAIL_ACL_POST },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 'e', MAIL_ACL_EXPUNGE },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 'k', MAIL_ACL_CREATE },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 'x', MAIL_ACL_DELETE },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { 'a', MAIL_ACL_ADMIN },
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    { '\0', NULL }
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen};
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainenconst char *imap_acl_plugin_version = DOVECOT_VERSION;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainenstatic struct module *imap_acl_module;
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainenstatic void (*next_hook_client_created)(struct client **client);
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainenstatic struct mailbox *
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainenacl_mailbox_open_as_admin(struct client_command_context *cmd, const char *name)
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen{
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen    struct mail_namespace *ns;
7c424aa51c956c628e3512055841aa2f9eef4833Timo Sirainen    struct mailbox *box;
f923659c0e5298263d80622c99f4dc4132b4675bTimo Sirainen    const char *storage_name;
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen    enum mailbox_name_status status;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    int ret;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    if (ACL_USER_CONTEXT(cmd->client->user) == NULL) {
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen        client_send_command_error(cmd, "ACLs disabled.");
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen        return NULL;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    }
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    ns = client_find_namespace(cmd, name, &storage_name, &status);
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    if (ns == NULL)
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen        return NULL;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    switch (status) {
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen    case MAILBOX_NAME_INVALID:
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    case MAILBOX_NAME_VALID:
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen        client_fail_mailbox_name_status(cmd, name, NULL, status);
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen        return NULL;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    default:
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen        break;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    }
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    /* Force opening the mailbox so that we can give a nicer error message
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen       if mailbox isn't selectable but is listable. */
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen    box = mailbox_alloc(ns->list, storage_name, ACL_MAILBOX_FLAGS |
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen                MAILBOX_FLAG_IGNORE_ACLS);
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    ret = acl_mailbox_right_lookup(box, ACL_STORAGE_RIGHT_ADMIN);
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    if (ret > 0)
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen        return box;
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    /* not an administrator. */
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen    if (acl_mailbox_right_lookup(box, ACL_STORAGE_RIGHT_LOOKUP) <= 0) {
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen        client_send_tagline(cmd, t_strdup_printf(
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen            "NO ["IMAP_RESP_CODE_NONEXISTENT"] "
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen            MAIL_ERRSTR_MAILBOX_NOT_FOUND, name));
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    } else {
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen        client_send_tagline(cmd, "NO "ERROR_NOT_ADMIN);
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    }
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    mailbox_free(&box);
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    return NULL;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen}
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainenstatic const struct imap_acl_letter_map *
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainenimap_acl_letter_map_find(const char *name)
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen{
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    unsigned int i;
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    for (i = 0; imap_acl_letter_map[i].name != NULL; i++) {
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen        if (strcmp(imap_acl_letter_map[i].name, name) == 0)
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen            return &imap_acl_letter_map[i];
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen    }
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainen    return NULL;
d65a556a5ec078cd7f1d0060adb16fc860d66b27Timo Sirainen}
d65a556a5ec078cd7f1d0060adb16fc860d66b27Timo Sirainen
d65a556a5ec078cd7f1d0060adb16fc860d66b27Timo Sirainenstatic void
812ac1e2570c600a086c09b24d250224a822a97dTimo Sirainenimap_acl_write_rights_list(string_t *dest, const char *const *rights)
847aeef259d42e2f14cf126699e28291e6e1fb53Timo Sirainen{
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    const struct imap_acl_letter_map *map;
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    unsigned int i, orig_len = str_len(dest);
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    bool append_c = FALSE, append_d = FALSE;
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    for (i = 0; rights[i] != NULL; i++) {
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        /* write only letters */
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        map = imap_acl_letter_map_find(rights[i]);
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        if (map != NULL) {
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen            str_append_c(dest, map->letter);
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen            if (map->letter == 'k' || map->letter == 'x')
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen                append_c = TRUE;
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen            if (map->letter == 't' || map->letter == 'e')
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen                append_d = TRUE;
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        }
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    }
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    if (append_c)
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        str_append_c(dest, 'c');
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    if (append_d)
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        str_append_c(dest, 'd');
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    if (orig_len == str_len(dest))
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        str_append(dest, "\"\"");
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen}
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainenstatic void
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainenimap_acl_write_right(string_t *dest, string_t *tmp,
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen             const struct acl_rights *right, bool neg)
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen{
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    const char *const *rights = neg ? right->neg_rights : right->rights;
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    str_truncate(tmp, 0);
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    if (neg) str_append_c(tmp,'-');
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    if (right->global)
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        str_append(tmp, IMAP_ACL_GLOBAL_PREFIX);
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    switch (right->id_type) {
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    case ACL_ID_ANYONE:
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        str_append(tmp, IMAP_ACL_ANYONE);
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        break;
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    case ACL_ID_AUTHENTICATED:
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        str_append(tmp, IMAP_ACL_AUTHENTICATED);
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        break;
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    case ACL_ID_OWNER:
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        str_append(tmp, IMAP_ACL_OWNER);
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        break;
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen    case ACL_ID_USER:
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        str_append(tmp, right->identifier);
72388282bf6718c39af34cfcf51438910f9d62daTimo Sirainen        break;
    case ACL_ID_GROUP:
        str_append(tmp, IMAP_ACL_GROUP_PREFIX);
        str_append(tmp, right->identifier);
        break;
    case ACL_ID_GROUP_OVERRIDE:
        str_append(tmp, IMAP_ACL_GROUP_OVERRIDE_PREFIX);
        str_append(tmp, right->identifier);
        break;
    case ACL_ID_TYPE_COUNT:
        i_unreached();
    }

    imap_quote_append(dest, str_data(tmp), str_len(tmp), FALSE);
    str_append_c(dest, ' ');
    imap_acl_write_rights_list(dest, rights);
}

static bool
acl_rights_is_owner(struct acl_backend *backend,
            const struct acl_rights *rights)
{
    switch (rights->id_type) {
    case ACL_ID_OWNER:
        return TRUE;
    case ACL_ID_USER:
        return acl_backend_user_name_equals(backend,
                            rights->identifier);
    default:
        return FALSE;
    }
}

static bool have_positive_owner_rights(struct acl_backend *backend,
                       struct acl_object *aclobj)
{
    struct acl_object_list_iter *iter;
    struct acl_rights rights;
    bool ret = FALSE;

    iter = acl_object_list_init(aclobj);
    while ((ret = acl_object_list_next(iter, &rights)) > 0) {
        if (acl_rights_is_owner(backend, &rights)) {
            if (rights.rights != NULL) {
                ret = TRUE;
                break;
            }
        }
    }
    acl_object_list_deinit(&iter);
    return ret;
}

static int
imap_acl_write_aclobj(string_t *dest, struct acl_backend *backend,
              struct acl_object *aclobj, bool convert_owner,
              bool add_default)
{
    struct acl_object_list_iter *iter;
    struct acl_rights rights;
    string_t *tmp;
    const char *username;
    unsigned int orig_len = str_len(dest);
    bool seen_owner = FALSE, seen_positive_owner = FALSE;
    int ret;

    username = acl_backend_get_acl_username(backend);
    if (username == NULL)
        convert_owner = FALSE;

    tmp = t_str_new(128);
    iter = acl_object_list_init(aclobj);
    while ((ret = acl_object_list_next(iter, &rights)) > 0) {
        if (acl_rights_is_owner(backend, &rights)) {
            if (rights.id_type == ACL_ID_OWNER && convert_owner) {
                rights.id_type = ACL_ID_USER;
                rights.identifier = username;
            }
            if (seen_owner && convert_owner) {
                /* oops, we have both owner and user=myself.
                   can't do the conversion, so try again. */
                str_truncate(dest, orig_len);
                return imap_acl_write_aclobj(dest, backend,
                                 aclobj, FALSE,
                                 add_default);
            }
            seen_owner = TRUE;
            if (rights.rights != NULL)
                seen_positive_owner = TRUE;
        }

        if (rights.rights != NULL) {
            str_append_c(dest, ' ');
            imap_acl_write_right(dest, tmp, &rights, FALSE);
        }
        if (rights.neg_rights != NULL) {
            str_append_c(dest, ' ');
            imap_acl_write_right(dest, tmp, &rights, TRUE);
        }
    }
    acl_object_list_deinit(&iter);

    if (!seen_positive_owner && username != NULL && add_default) {
        /* no positive owner rights returned, write default ACLs */
        memset(&rights, 0, sizeof(rights));
        if (!convert_owner) {
            rights.id_type = ACL_ID_OWNER;
        } else {
            rights.id_type = ACL_ID_USER;
            rights.identifier = username;
        }
        rights.rights = acl_object_get_default_rights(aclobj);
        if (rights.rights != NULL) {
            str_append_c(dest, ' ');
            imap_acl_write_right(dest, tmp, &rights, FALSE);
        }
    }
    return ret;
}

static bool cmd_getacl(struct client_command_context *cmd)
{
    struct acl_backend *backend;
    struct mail_namespace *ns;
    struct mailbox *box;
    const char *mailbox;
    string_t *str;
    int ret;

    if (!client_read_string_args(cmd, 1, &mailbox))
        return FALSE;

    box = acl_mailbox_open_as_admin(cmd, mailbox);
    if (box == NULL)
        return TRUE;

    str = t_str_new(128);
    str_append(str, "* ACL ");
    imap_quote_append_string(str, mailbox, FALSE);

    ns = mailbox_get_namespace(box);
    backend = acl_mailbox_list_get_backend(ns->list);
    ret = imap_acl_write_aclobj(str, backend,
                    acl_mailbox_get_aclobj(box), TRUE,
                    ns->type == NAMESPACE_PRIVATE);
    if (ret == 0) {
        client_send_line(cmd->client, str_c(str));
        client_send_tagline(cmd, "OK Getacl completed.");
    } else {
        client_send_tagline(cmd, "NO "MAIL_ERRSTR_CRITICAL_MSG);
    }
    mailbox_free(&box);
    return TRUE;
}

static bool cmd_myrights(struct client_command_context *cmd)
{
    struct mail_namespace *ns;
    struct mailbox *box;
    const char *mailbox, *storage_name;
    const char *const *rights;
    string_t *str;

    if (!client_read_string_args(cmd, 1, &mailbox))
        return FALSE;

    if (ACL_USER_CONTEXT(cmd->client->user) == NULL) {
        client_send_command_error(cmd, "ACLs disabled.");
        return TRUE;
    }

    ns = client_find_namespace(cmd, mailbox, &storage_name, NULL);
    if (ns == NULL)
        return TRUE;

    box = mailbox_alloc(ns->list, storage_name,
                ACL_MAILBOX_FLAGS | MAILBOX_FLAG_IGNORE_ACLS);
    if (acl_object_get_my_rights(acl_mailbox_get_aclobj(box),
                     pool_datastack_create(), &rights) < 0) {
        client_send_tagline(cmd, "NO "MAIL_ERRSTR_CRITICAL_MSG);
        mailbox_free(&box);
        return TRUE;
    }
    /* Post right alone doesn't give permissions to see if the mailbox
       exists or not. Only mail deliveries care about that. */
    if (*rights == NULL ||
        (strcmp(*rights, MAIL_ACL_POST) == 0 && rights[1] == NULL)) {
        client_send_tagline(cmd, t_strdup_printf(
            "NO ["IMAP_RESP_CODE_NONEXISTENT"] "
            MAIL_ERRSTR_MAILBOX_NOT_FOUND, mailbox));
        mailbox_free(&box);
        return TRUE;
    }

    str = t_str_new(128);
    str_append(str, "* MYRIGHTS ");
    imap_quote_append_string(str, mailbox, FALSE);
    str_append_c(str,' ');
    imap_acl_write_rights_list(str, rights);

    client_send_line(cmd->client, str_c(str));
    client_send_tagline(cmd, "OK Myrights completed.");
    mailbox_free(&box);
    return TRUE;
}

static bool cmd_listrights(struct client_command_context *cmd)
{
    struct mailbox *box;
    const char *mailbox, *identifier;
    string_t *str;

    if (!client_read_string_args(cmd, 2, &mailbox, &identifier))
        return FALSE;

    box = acl_mailbox_open_as_admin(cmd, mailbox);
    if (box == NULL)
        return TRUE;

    str = t_str_new(128);
    str_append(str, "* LISTRIGHTS ");
    imap_quote_append_string(str, mailbox, FALSE);
    str_append_c(str, ' ');
    imap_quote_append_string(str, identifier, FALSE);
    str_append_c(str, ' ');
    str_append(str, "\"\" l r w s t p i e k x a c d");

    client_send_line(cmd->client, str_c(str));
    client_send_tagline(cmd, "OK Listrights completed.");
    mailbox_free(&box);
    return TRUE;
}

static int
imap_acl_letters_parse(const char *letters, const char *const **rights_r,
               const char **error_r)
{
    static const char *acl_k = MAIL_ACL_CREATE;
    static const char *acl_x = MAIL_ACL_DELETE;
    static const char *acl_e = MAIL_ACL_EXPUNGE;
    static const char *acl_t = MAIL_ACL_WRITE_DELETED;
    ARRAY_TYPE(const_string) rights;
    unsigned int i;

    t_array_init(&rights, 64);
    for (; *letters != '\0'; letters++) {
        for (i = 0; imap_acl_letter_map[i].name != NULL; i++) {
            if (imap_acl_letter_map[i].letter == *letters) {
                array_append(&rights,
                         &imap_acl_letter_map[i].name, 1);
                break;
            }
        }
        if (imap_acl_letter_map[i].name == NULL) {
            /* Handling of obsolete rights as virtual
               rights according to RFC 4314 */
            switch (*letters) {
            case 'c':
                array_append(&rights, &acl_k, 1);
                array_append(&rights, &acl_x, 1);
                break;
            case 'd':
                array_append(&rights, &acl_e, 1);
                array_append(&rights, &acl_t, 1);
                break;
            default:
                *error_r = t_strdup_printf(
                    "Invalid ACL right: %c", *letters);
                return -1;
            }
        }
    }
    (void)array_append_space(&rights);
    *rights_r = array_idx(&rights, 0);
    return 0;
}

static bool acl_anyone_allow(struct mail_user *user)
{
    const char *env;

    env = mail_user_plugin_getenv(user, "acl_anyone");
    return env != NULL && strcmp(env, "allow") == 0;
}

static int
imap_acl_identifier_parse(struct client_command_context *cmd,
              const char *id, struct acl_rights *rights,
              bool check_anyone, const char **error_r)
{
    struct mail_user *user = cmd->client->user;

    if (strncmp(id, IMAP_ACL_GLOBAL_PREFIX,
            strlen(IMAP_ACL_GLOBAL_PREFIX)) == 0) {
        *error_r = t_strdup_printf("Global ACLs can't be modified: %s",
                       id);
        return -1;
    }

    if (strcmp(id, IMAP_ACL_ANYONE) == 0) {
        if (check_anyone && !acl_anyone_allow(user)) {
            *error_r = "'anyone' identifier is disallowed";
            return -1;
        }
        rights->id_type = ACL_ID_ANYONE;
    } else if (strcmp(id, IMAP_ACL_AUTHENTICATED) == 0) {
        if (check_anyone && !acl_anyone_allow(user)) {
            *error_r = "'authenticated' identifier is disallowed";
            return -1;
        }
        rights->id_type = ACL_ID_AUTHENTICATED;
    } else if (strcmp(id, IMAP_ACL_OWNER) == 0)
        rights->id_type = ACL_ID_OWNER;
    else if (strncmp(id, IMAP_ACL_GROUP_PREFIX,
             strlen(IMAP_ACL_GROUP_PREFIX)) == 0) {
        rights->id_type = ACL_ID_GROUP;
        rights->identifier = id + strlen(IMAP_ACL_GROUP_PREFIX);
    } else if (strncmp(id, IMAP_ACL_GROUP_OVERRIDE_PREFIX,
               strlen(IMAP_ACL_GROUP_OVERRIDE_PREFIX)) == 0) {
        rights->id_type = ACL_ID_GROUP_OVERRIDE;
        rights->identifier = id +
            strlen(IMAP_ACL_GROUP_OVERRIDE_PREFIX);
    } else {
        rights->id_type = ACL_ID_USER;
        rights->identifier = id;
    }
    return 0;
}

static void imap_acl_update_ensure_keep_admins(struct acl_backend *backend,
                           struct acl_object *aclobj,
                           struct acl_rights_update *update)
{
    static const char *acl_admin = MAIL_ACL_ADMIN;
    const char *const *rights = update->rights.rights;
    const char *const *default_rights;
    ARRAY_TYPE(const_string) new_rights;
    unsigned int i;

    t_array_init(&new_rights, 64);
    for (i = 0; rights[i] != NULL; i++) {
        if (strcmp(rights[i], MAIL_ACL_ADMIN) == 0)
            break;
        array_append(&new_rights, &rights[i], 1);
    }

    switch (update->modify_mode) {
    case ACL_MODIFY_MODE_ADD:
        if (have_positive_owner_rights(backend, aclobj))
            return;

        /* adding initial rights for a user. we need to add
           the defaults also. don't worry about duplicates. */
        for (; rights[i] != NULL; i++)
            array_append(&new_rights, &rights[i], 1);
        default_rights = acl_object_get_default_rights(aclobj);
        for (i = 0; default_rights[i] != NULL; i++)
            array_append(&new_rights, &default_rights[i], 1);
        break;
    case ACL_MODIFY_MODE_REMOVE:
        if (rights[i] == NULL)
            return;

        /* skip over the ADMIN removal and add the rest */
        for (i++; rights[i] != NULL; i++)
            array_append(&new_rights, &rights[i], 1);
        break;
    case ACL_MODIFY_MODE_REPLACE:
        if (rights[i] != NULL)
            return;

        /* add the missing ADMIN right */
        array_append(&new_rights, &acl_admin, 1);
        break;
    default:
        return;
    }
    (void)array_append_space(&new_rights);
    update->rights.rights = array_idx(&new_rights, 0);
}

static bool cmd_setacl(struct client_command_context *cmd)
{
    struct mail_namespace *ns;
    struct mailbox *box;
    struct acl_backend *backend;
    struct acl_object *aclobj;
    struct acl_rights_update update;
    struct acl_rights *r;
    const char *mailbox, *identifier, *rights, *error;
    bool negative = FALSE;

    if (!client_read_string_args(cmd, 3, &mailbox, &identifier, &rights))
        return FALSE;

    if (*identifier == '\0') {
        client_send_command_error(cmd, "Invalid arguments.");
        return TRUE;
    }

    memset(&update, 0, sizeof(update));
    if (*identifier == '-') {
        negative = TRUE;
        identifier++;
    }

    switch (*rights) {
    case '-':
        update.modify_mode = ACL_MODIFY_MODE_REMOVE;
        rights++;
        break;
    case '+':
        update.modify_mode = ACL_MODIFY_MODE_ADD;
        rights++;
        break;
    default:
        update.modify_mode = ACL_MODIFY_MODE_REPLACE;
        break;
    }

    if (imap_acl_identifier_parse(cmd, identifier, &update.rights,
                      TRUE, &error) < 0) {
        client_send_command_error(cmd, error);
        return TRUE;
    }
    if (imap_acl_letters_parse(rights, &update.rights.rights, &error) < 0) {
        client_send_command_error(cmd, error);
        return TRUE;
    }
    r = &update.rights;

    box = acl_mailbox_open_as_admin(cmd, mailbox);
    if (box == NULL)
        return TRUE;

    ns = mailbox_get_namespace(box);
    backend = acl_mailbox_list_get_backend(ns->list);
    if (ns->type == NAMESPACE_PUBLIC && r->id_type == ACL_ID_OWNER) {
        client_send_tagline(cmd, "NO Public namespaces have no owner");
        mailbox_free(&box);
        return TRUE;
    }

    aclobj = acl_mailbox_get_aclobj(box);
    if (negative) {
        update.neg_modify_mode = update.modify_mode;
        update.modify_mode = ACL_MODIFY_MODE_REMOVE;
        update.rights.neg_rights = update.rights.rights;
        update.rights.rights = NULL;
    } else if (ns->type == NAMESPACE_PRIVATE && r->rights != NULL &&
           ((r->id_type == ACL_ID_USER &&
             acl_backend_user_name_equals(backend, r->identifier)) ||
            (r->id_type == ACL_ID_OWNER &&
             strcmp(acl_backend_get_acl_username(backend),
                ns->user->username) == 0))) {
        /* make sure client doesn't (accidentally) remove admin
           privileges from its own mailboxes */
        imap_acl_update_ensure_keep_admins(backend, aclobj, &update);
    }

    if (acl_object_update(aclobj, &update) < 0)
        client_send_tagline(cmd, "NO "MAIL_ERRSTR_CRITICAL_MSG);
    else
        client_send_tagline(cmd, "OK Setacl complete.");
    mailbox_free(&box);
    return TRUE;
}

static bool cmd_deleteacl(struct client_command_context *cmd)
{
    struct mailbox *box;
    struct acl_rights_update update;
    const char *mailbox, *identifier, *error;

    if (!client_read_string_args(cmd, 2, &mailbox, &identifier))
        return FALSE;
    if (*identifier == '\0') {
        client_send_command_error(cmd, "Invalid arguments.");
        return TRUE;
    }

    memset(&update, 0, sizeof(update));
    if (*identifier != '-')
        update.modify_mode = ACL_MODIFY_MODE_CLEAR;
    else {
        update.neg_modify_mode = ACL_MODIFY_MODE_CLEAR;
        identifier++;
    }

    if (imap_acl_identifier_parse(cmd, identifier, &update.rights,
                      FALSE, &error) < 0) {
        client_send_command_error(cmd, error);
        return TRUE;
    }

    box = acl_mailbox_open_as_admin(cmd, mailbox);
    if (box == NULL)
        return TRUE;

    if (acl_object_update(acl_mailbox_get_aclobj(box), &update) < 0)
        client_send_tagline(cmd, "NO "MAIL_ERRSTR_CRITICAL_MSG);
    else
        client_send_tagline(cmd, "OK Deleteacl complete.");
    mailbox_free(&box);
    return TRUE;
}

static void imap_acl_client_created(struct client **client)
{
    if (mail_user_is_plugin_loaded((*client)->user, imap_acl_module))
        str_append((*client)->capability_string, " ACL RIGHTS=texk");

    if (next_hook_client_created != NULL)
        next_hook_client_created(client);
}

void imap_acl_plugin_init(struct module *module)
{
    command_register("LISTRIGHTS", cmd_listrights, 0);
    command_register("GETACL", cmd_getacl, 0);
    command_register("MYRIGHTS", cmd_myrights, 0);
    command_register("SETACL", cmd_setacl, 0);
    command_register("DELETEACL", cmd_deleteacl, 0);

    imap_acl_module = module;
    next_hook_client_created =
        imap_client_created_hook_set(imap_acl_client_created);
}

void imap_acl_plugin_deinit(void)
{
    command_unregister("GETACL");
    command_unregister("MYRIGHTS");
    command_unregister("SETACL");
    command_unregister("DELETEACL");
    command_unregister("LISTRIGHTS");

    imap_client_created_hook_set(next_hook_client_created);
}

const char *imap_acl_plugin_dependencies[] = { "acl", NULL };
const char imap_acl_plugin_binary_dependency[] = "imap";