xattr_acl.c

Go to the documentation of this file.

/*
 * linux/fs/xattr_acl.c
 *
 * Almost all from linux/fs/ext2/acl.c:
 * Copyright (C) 2001 by Andreas Gruenbacher, <[email protected]>
 */

#include <linux/export.h>
#include <linux/fs.h>
#include <linux/posix_acl_xattr.h>
#include <linux/gfp.h>
#include <linux/user_namespace.h>

/*
 * Fix up the uids and gids in posix acl extended attributes in place.
 */
static void posix_acl_fix_xattr_userns(
    struct user_namespace *to, struct user_namespace *from,
    void *value, size_t size)
{
    posix_acl_xattr_header *header = (posix_acl_xattr_header *)value;
    posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;
    int count;
    kuid_t uid;
    kgid_t gid;

    if (!value)
        return;
    if (size < sizeof(posix_acl_xattr_header))
        return;
    if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
        return;

    count = posix_acl_xattr_count(size);
    if (count < 0)
        return;
    if (count == 0)
        return;

    for (end = entry + count; entry != end; entry++) {
        switch(le16_to_cpu(entry->e_tag)) {
        case ACL_USER:
            uid = make_kuid(from, le32_to_cpu(entry->e_id));
            entry->e_id = cpu_to_le32(from_kuid(to, uid));
            break;
        case ACL_GROUP:
            gid = make_kgid(from, le32_to_cpu(entry->e_id));
            entry->e_id = cpu_to_le32(from_kgid(to, gid));
            break;
        default:
            break;
        }
    }
}

void posix_acl_fix_xattr_from_user(void *value, size_t size)
{
    struct user_namespace *user_ns = current_user_ns();
    if (user_ns == &init_user_ns)
        return;
    posix_acl_fix_xattr_userns(&init_user_ns, user_ns, value, size);
}

void posix_acl_fix_xattr_to_user(void *value, size_t size)
{
    struct user_namespace *user_ns = current_user_ns();
    if (user_ns == &init_user_ns)
        return;
    posix_acl_fix_xattr_userns(user_ns, &init_user_ns, value, size);
}

/*
 * Convert from extended attribute to in-memory representation.
 */
struct posix_acl *
posix_acl_from_xattr(struct user_namespace *user_ns,
             const void *value, size_t size)
{
    posix_acl_xattr_header *header = (posix_acl_xattr_header *)value;
    posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;
    int count;
    struct posix_acl *acl;
    struct posix_acl_entry *acl_e;

    if (!value)
        return NULL;
    if (size < sizeof(posix_acl_xattr_header))
         return ERR_PTR(-EINVAL);
    if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
        return ERR_PTR(-EOPNOTSUPP);

    count = posix_acl_xattr_count(size);
    if (count < 0)
        return ERR_PTR(-EINVAL);
    if (count == 0)
        return NULL;
    
    acl = posix_acl_alloc(count, GFP_NOFS);
    if (!acl)
        return ERR_PTR(-ENOMEM);
    acl_e = acl->a_entries;
    
    for (end = entry + count; entry != end; acl_e++, entry++) {
        acl_e->e_tag  = le16_to_cpu(entry->e_tag);
        acl_e->e_perm = le16_to_cpu(entry->e_perm);

        switch(acl_e->e_tag) {
            case ACL_USER_OBJ:
            case ACL_GROUP_OBJ:
            case ACL_MASK:
            case ACL_OTHER:
                break;

            case ACL_USER:
                acl_e->e_uid =
                    make_kuid(user_ns,
                          le32_to_cpu(entry->e_id));
                if (!uid_valid(acl_e->e_uid))
                    goto fail;
                break;
            case ACL_GROUP:
                acl_e->e_gid =
                    make_kgid(user_ns,
                          le32_to_cpu(entry->e_id));
                if (!gid_valid(acl_e->e_gid))
                    goto fail;
                break;

            default:
                goto fail;
        }
    }
    return acl;

fail:
    posix_acl_release(acl);
    return ERR_PTR(-EINVAL);
}
EXPORT_SYMBOL (posix_acl_from_xattr);

/*
 * Convert from in-memory to extended attribute representation.
 */
int
posix_acl_to_xattr(struct user_namespace *user_ns, const struct posix_acl *acl,
           void *buffer, size_t size)
{
    posix_acl_xattr_header *ext_acl = (posix_acl_xattr_header *)buffer;
    posix_acl_xattr_entry *ext_entry = ext_acl->a_entries;
    int real_size, n;

    real_size = posix_acl_xattr_size(acl->a_count);
    if (!buffer)
        return real_size;
    if (real_size > size)
        return -ERANGE;
    
    ext_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);

    for (n=0; n < acl->a_count; n++, ext_entry++) {
        const struct posix_acl_entry *acl_e = &acl->a_entries[n];
        ext_entry->e_tag  = cpu_to_le16(acl_e->e_tag);
        ext_entry->e_perm = cpu_to_le16(acl_e->e_perm);
        switch(acl_e->e_tag) {
        case ACL_USER:
            ext_entry->e_id =
                cpu_to_le32(from_kuid(user_ns, acl_e->e_uid));
            break;
        case ACL_GROUP:
            ext_entry->e_id =
                cpu_to_le32(from_kgid(user_ns, acl_e->e_gid));
            break;
        default:
            ext_entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID);
            break;
        }
    }
    return real_size;
}
EXPORT_SYMBOL (posix_acl_to_xattr);